682 files changed, 213251 insertions, 1245 deletions

diff --git a/source/blender/SConscript b/source/blender/SConscript
index 56a661238f8..09d30ddafd0 100644
--- a/source/blender/SConscript
+++ b/source/blender/SConscript
@@ -31,3 +31,6 @@ if env['WITH_BF_OPENEXR'] == 1:
 
 if env['WITH_BF_QUICKTIME'] == 1:
     SConscript (['quicktime/SConscript'])
+
+if env['WITH_BF_FREESTYLE'] == 1:
+       SConscript(['freestyle/SConscript'])
diff --git a/source/blender/blenkernel/BKE_global.h b/source/blender/blenkernel/BKE_global.h
index 62289d227c7..8c9634cba06 100644
--- a/source/blender/blenkernel/BKE_global.h
+++ b/source/blender/blenkernel/BKE_global.h
@@ -175,6 +175,7 @@ typedef struct Global {
 #define G_WEIGHTPAINT	(1 << 15)	
 #define G_TEXTUREPAINT	(1 << 16)
 /* #define G_NOFROZEN	(1 << 17) also removed */
+#define G_GREASEPENCIL 	(1 << 17)
 #define G_DRAWEDGES		(1 << 18)
 #define G_DRAWCREASES	(1 << 19)
 #define G_DRAWSEAMS     (1 << 20)
@@ -265,3 +266,4 @@ extern Global G;
 	
 #endif
 
+
diff --git a/source/blender/blenkernel/intern/collision.c b/source/blender/blenkernel/intern/collision.c
index 26c5d186d87..6dfb77504fb 100644
--- a/source/blender/blenkernel/intern/collision.c
+++ b/source/blender/blenkernel/intern/collision.c
@@ -1437,6 +1437,9 @@ CollisionModifierData **get_collisionobjects(Object *self, int *numcollobj)
 
 					if(coll_ob == self)
 						continue;
+					
+					if( !collmd->bvhtree)
+						continue;
 
 					if(numobj >= maxobj)
 					{
diff --git a/source/blender/blenkernel/intern/lattice.c b/source/blender/blenkernel/intern/lattice.c
index e8bcae42d5a..54915058bab 100644
--- a/source/blender/blenkernel/intern/lattice.c
+++ b/source/blender/blenkernel/intern/lattice.c
@@ -915,7 +915,10 @@ void lattice_calc_modifiers(Object *ob)
 		mti->deformVerts(md, ob, NULL, vertexCos, numVerts);
 	}
 
-	if (vertexCos) {
+	/* always displist to make this work like derivedmesh */
+	if (!vertexCos) vertexCos = lattice_getVertexCos(ob, &numVerts);
+	
+	{
 		DispList *dl = MEM_callocN(sizeof(*dl), "lt_dl");
 		dl->type = DL_VERTS;
 		dl->parts = 1;
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index f70648965f4..7dca87d5c13 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -2797,7 +2797,10 @@ void do_effectors(int pa_no, ParticleData *pa, ParticleKey *state, Object *ob, P
 				epart= epsys->part;
 				pd= epart->pd;
 				totepart= epsys->totpart;
-
+				
+				if(totepart <= 0)
+					continue;
+				
 				if(pd->forcefield==PFIELD_HARMONIC){
 					/* every particle is mapped to only one harmonic effector particle */
 					p= pa_no%epsys->totpart;
diff --git a/source/blender/blenlib/intern/arithb.c b/source/blender/blenlib/intern/arithb.c
index c97ca3c6a8a..b7598ec0c4d 100644
--- a/source/blender/blenlib/intern/arithb.c
+++ b/source/blender/blenlib/intern/arithb.c
@@ -60,6 +60,7 @@
 #define SMALL_NUMBER	1.e-8
 #define ABS(x)	((x) < 0 ? -(x) : (x))
 #define SWAP(type, a, b)	{ type sw_ap; sw_ap=(a); (a)=(b); (b)=sw_ap; }
+#define CLAMP(a, b, c)		if((a)<(b)) (a)=(b); else if((a)>(c)) (a)=(c)
 
 
 #if defined(WIN32) || defined(__APPLE__)
@@ -3800,12 +3801,50 @@ int RayIntersectsTriangle(float p1[3], float d[3], float v0[3], float v1[3], flo
 
 /* Adapted from the paper by Kasper Fauerby */
 /* "Improved Collision detection and Response" */
+static int getLowestRoot(float a, float b, float c, float maxR, float* root)
+{
+	// Check if a solution exists
+	float determinant = b*b - 4.0f*a*c;
+
+	// If determinant is negative it means no solutions.
+	if (determinant >= 0.0f)
+	{
+		// calculate the two roots: (if determinant == 0 then
+		// x1==x2 but let’s disregard that slight optimization)
+		float sqrtD = sqrt(determinant);
+		float r1 = (-b - sqrtD) / (2.0f*a);
+		float r2 = (-b + sqrtD) / (2.0f*a);
+		
+		// Sort so x1 <= x2
+		if (r1 > r2)
+			SWAP( float, r1, r2);
+
+		// Get lowest root:
+		if (r1 > 0.0f && r1 < maxR)
+		{
+			*root = r1;
+			return 1;
+		}
+
+		// It is possible that we want x2 - this can happen
+		// if x1 < 0
+		if (r2 > 0.0f && r2 < maxR)
+		{
+			*root = r2;
+			return 1;
+		}
+	}
+	// No (valid) solutions
+	return 0;
+}
+
 int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, float v0[3], float v1[3], float v2[3], float *lambda, float *ipoint)
 {
 	float e1[3], e2[3], e3[3], point[3], vel[3], /*dist[3],*/ nor[3], temp[3], bv[3];
-	float a, b, c, d, e, x, y, z, t, t0, t1, radius2=radius*radius;
+	float a, b, c, d, e, x, y, z, radius2=radius*radius;
 	float elen2,edotv,edotbv,nordotv,vel2;
-	int embedded_in_plane=0, found_by_sweep=0;
+	float newLambda;
+	int found_by_sweep=0;
 
 	VecSubf(e1,v1,v0);
 	VecSubf(e2,v2,v0);
@@ -3814,44 +3853,41 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 /*---test plane of tri---*/
 	Crossf(nor,e1,e2);
 	Normalize(nor);
+
 	/* flip normal */
 	if(Inpf(nor,vel)>0.0f) VecMulf(nor,-1.0f);
 	
 	a=Inpf(p1,nor)-Inpf(v0,nor);
-
 	nordotv=Inpf(nor,vel);
 
-	if ((nordotv > -0.000001) && (nordotv < 0.000001)) {
-		if(fabs(a)>=1.0f)
+	if (fabs(nordotv) < 0.000001)
+	{
+		if(fabs(a)>=radius)
+		{
 			return 0;
-		else{
-			embedded_in_plane=1;
-			t0=0.0f;
-			t1=1.0f;
 		}
 	}
-	else{
-		t0=(radius-a)/nordotv;
-		t1=(-radius-a)/nordotv;
-		/* make t0<t1 */
-		if(t0>t1){b=t1; t1=t0; t0=b;}
+	else
+	{
+		float t0=(-a+radius)/nordotv;
+		float t1=(-a-radius)/nordotv;
+
+		if(t0>t1)
+			SWAP(float, t0, t1);
 
 		if(t0>1.0f || t1<0.0f) return 0;
 
 		/* clamp to [0,1] */
-		t0=(t0<0.0f)?0.0f:((t0>1.0f)?1.0:t0);
-		t1=(t1<0.0f)?0.0f:((t1>1.0f)?1.0:t1);
-	}
+		CLAMP(t0, 0.0f, 1.0f);
+		CLAMP(t1, 0.0f, 1.0f);
 
-/*---test inside of tri---*/
-	if(embedded_in_plane==0){
+		/*---test inside of tri---*/
 		/* plane intersection point */
-		VecCopyf(point,vel);
-		VecMulf(point,t0);
-		VecAddf(point,point,p1);
-		VecCopyf(temp,nor);
-		VecMulf(temp,radius);
-		VecSubf(point,point,temp);
+
+		point[0] = p1[0] + vel[0]*t0 - nor[0]*radius;
+		point[1] = p1[1] + vel[1]*t0 - nor[1]*radius;
+		point[2] = p1[2] + vel[2]*t0 - nor[2]*radius;
+
 
 		/* is the point in the tri? */
 		a=Inpf(e1,e1);
@@ -3866,14 +3902,19 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 		y=e*a-d*b;
 		z=x+y-(a*c-b*b);
 
-		if(( ((unsigned int)z)& ~(((unsigned int)x)|((unsigned int)y)) ) & 0x80000000){
+
+		if( z <= 0.0f && (x >= 0.0f && y >= 0.0f))
+		{
+		//( ((unsigned int)z)& ~(((unsigned int)x)|((unsigned int)y)) ) & 0x80000000){
 			*lambda=t0;
 			VecCopyf(ipoint,point);
 			return 1;
 		}
 	}
 
+
 	*lambda=1.0f;
+
 /*---test points---*/
 	a=vel2=Inpf(vel,vel);
 
@@ -3881,73 +3922,42 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 	VecSubf(temp,p1,v0);
 	b=2.0f*Inpf(vel,temp);
 	c=Inpf(temp,temp)-radius2;
-	d=b*b-4*a*c;
-
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		if(t>0.0 && t < *lambda){
-			*lambda=t;
-			VecCopyf(ipoint,v0);
-			found_by_sweep=1;
-		}
+	if(getLowestRoot(a, b, c, *lambda, lambda))
+	{
+		VecCopyf(ipoint,v0);
+		found_by_sweep=1;
 	}
 
 	/*v1*/
 	VecSubf(temp,p1,v1);
 	b=2.0f*Inpf(vel,temp);
 	c=Inpf(temp,temp)-radius2;
-	d=b*b-4*a*c;
-
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		if(t>0.0 && t < *lambda){
-			*lambda=t;
-			VecCopyf(ipoint,v1);
-			found_by_sweep=1;
-		}
+	if(getLowestRoot(a, b, c, *lambda, lambda))
+	{
+		VecCopyf(ipoint,v1);
+		found_by_sweep=1;
 	}
+	
 	/*v2*/
 	VecSubf(temp,p1,v2);
 	b=2.0f*Inpf(vel,temp);
 	c=Inpf(temp,temp)-radius2;
-	d=b*b-4*a*c;
-
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		if(t>0.0 && t < *lambda){
-			*lambda=t;
-			VecCopyf(ipoint,v2);
-			found_by_sweep=1;
-		}
+	if(getLowestRoot(a, b, c, *lambda, lambda))
+	{
+		VecCopyf(ipoint,v2);
+		found_by_sweep=1;
 	}
 
 /*---test edges---*/
+	VecSubf(e3,v2,v1); //wasnt yet calculated
+
+
 	/*e1*/
 	VecSubf(bv,v0,p1);
+
 	elen2 = Inpf(e1,e1);
 	edotv = Inpf(e1,vel);
 	edotbv = Inpf(e1,bv);
@@ -3955,27 +3965,18 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 	a=elen2*(-Inpf(vel,vel))+edotv*edotv;
 	b=2.0f*(elen2*Inpf(vel,bv)-edotv*edotbv);
 	c=elen2*(radius2-Inpf(bv,bv))+edotbv*edotbv;
-	d=b*b-4*a*c;
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		e=(edotv*t-edotbv)/elen2;
+	if(getLowestRoot(a, b, c, *lambda, &newLambda))
+	{
+		e=(edotv*newLambda-edotbv)/elen2;
 
-		if((e>=0.0f) && (e<=1.0f)){
-			if(t>0.0 && t < *lambda){
-				*lambda=t;
-				VecCopyf(ipoint,e1);
-				VecMulf(ipoint,e);
-				VecAddf(ipoint,ipoint,v0);
-				found_by_sweep=1;
-			}
+		if(e >= 0.0f && e <= 1.0f)
+		{
+			*lambda = newLambda;
+			VecCopyf(ipoint,e1);
+			VecMulf(ipoint,e);
+			VecAddf(ipoint,ipoint,v0);
+			found_by_sweep=1;
 		}
 	}
 
@@ -3988,32 +3989,27 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 	a=elen2*(-Inpf(vel,vel))+edotv*edotv;
 	b=2.0f*(elen2*Inpf(vel,bv)-edotv*edotbv);
 	c=elen2*(radius2-Inpf(bv,bv))+edotbv*edotbv;
-	d=b*b-4*a*c;
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		e=(edotv*t-edotbv)/elen2;
+	if(getLowestRoot(a, b, c, *lambda, &newLambda))
+	{
+		e=(edotv*newLambda-edotbv)/elen2;
 
-		if((e>=0.0f) && (e<=1.0f)){
-			if(t>0.0 && t < *lambda){
-				*lambda=t;
-				VecCopyf(ipoint,e2);
-				VecMulf(ipoint,e);
-				VecAddf(ipoint,ipoint,v0);
-				found_by_sweep=1;
-			}
+		if(e >= 0.0f && e <= 1.0f)
+		{
+			*lambda = newLambda;
+			VecCopyf(ipoint,e2);
+			VecMulf(ipoint,e);
+			VecAddf(ipoint,ipoint,v0);
+			found_by_sweep=1;
 		}
 	}
 
 	/*e3*/
-	VecSubf(e3,v2,v1);
+	VecSubf(bv,v0,p1);
+	elen2 = Inpf(e1,e1);
+	edotv = Inpf(e1,vel);
+	edotbv = Inpf(e1,bv);
+
 	VecSubf(bv,v1,p1);
 	elen2 = Inpf(e3,e3);
 	edotv = Inpf(e3,vel);
@@ -4022,30 +4018,22 @@ int SweepingSphereIntersectsTriangleUV(float p1[3], float p2[3], float radius, f
 	a=elen2*(-Inpf(vel,vel))+edotv*edotv;
 	b=2.0f*(elen2*Inpf(vel,bv)-edotv*edotbv);
 	c=elen2*(radius2-Inpf(bv,bv))+edotbv*edotbv;
-	d=b*b-4*a*c;
-	if(d>=0.0f){
-		if(d==0.0f)
-			t=-b/2*a;
-		else{
-			z=sqrt(d);
-			x=(-b-z)*0.5/a;
-			y=(-b+z)*0.5/a;
-			t=x<y?x:y;
-		}
 
-		e=(edotv*t-edotbv)/elen2;
+	if(getLowestRoot(a, b, c, *lambda, &newLambda))
+	{
+		e=(edotv*newLambda-edotbv)/elen2;
 
-		if((e>=0.0f) && (e<=1.0f)){
-			if(t>0.0 && t < *lambda){
-				*lambda=t;
-				VecCopyf(ipoint,e3);
-				VecMulf(ipoint,e);
-				VecAddf(ipoint,ipoint,v1);
-				found_by_sweep=1;
-			}
+		if(e >= 0.0f && e <= 1.0f)
+		{
+			*lambda = newLambda;
+			VecCopyf(ipoint,e3);
+			VecMulf(ipoint,e);
+			VecAddf(ipoint,ipoint,v1);
+			found_by_sweep=1;
 		}
 	}
 
+
 	return found_by_sweep;
 }
 int AxialLineIntersectsTriangle(int axis, float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda)
diff --git a/source/blender/blenlib/intern/storage.c b/source/blender/blenlib/intern/storage.c
index fbcc56ac21d..ca7a376d3a2 100644
--- a/source/blender/blenlib/intern/storage.c
+++ b/source/blender/blenlib/intern/storage.c
@@ -382,7 +382,6 @@ void BLI_adddirstrings()
 			pwuser = getpwuid(files[num].s.st_uid);
 			if ( pwuser ) {
 			strcpy(files[num].owner, pwuser->pw_name);
-			free(pwuser);
 			} else {
 				sprintf(files[num].owner, "%d", files[num].s.st_uid);
             }
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index 3c629818b2d..090b1d7c6b6 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -69,6 +69,7 @@
 #include "DNA_effect_types.h"
 #include "DNA_fileglobal_types.h"
 #include "DNA_group_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_ipo_types.h"
 #include "DNA_image_types.h"
 #include "DNA_key_types.h"
@@ -3698,6 +3699,32 @@ static void lib_link_screen_sequence_ipos(Main *main)
 
 /* ************ READ SCREEN ***************** */
 
+/* relinks grease-pencil data for 3d-view(s) - used for direct_link */
+static void link_gpencil(FileData *fd, bGPdata *gpd)
+{
+	bGPDlayer *gpl;
+	bGPDframe *gpf;
+	bGPDstroke *gps;
+	
+	/* relink layers */
+	link_list(fd, &gpd->layers);
+	
+	for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+		/* relink frames */
+		link_list(fd, &gpl->frames);
+		gpl->actframe= newdataadr(fd, gpl->actframe);
+		
+		for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+			/* relink strokes (and their points) */
+			link_list(fd, &gpf->strokes);
+			
+			for (gps= gpf->strokes.first; gps; gps= gps->next) {
+				gps->points= newdataadr(fd, gps->points);
+			}
+		}
+	}
+}
+
 /* note: file read without screens option G_FILE_NO_UI; 
    check lib pointers in call below */
 static void lib_link_screen(FileData *fd, Main *main)
@@ -3709,23 +3736,23 @@ static void lib_link_screen(FileData *fd, Main *main)
 		if(sc->id.flag & LIB_NEEDLINK) {
 			sc->id.us= 1;
 			sc->scene= newlibadr(fd, sc->id.lib, sc->scene);
-
+			
 			sa= sc->areabase.first;
 			while(sa) {
 				SpaceLink *sl;
-
+				
 				sa->full= newlibadr(fd, sc->id.lib, sa->full);
-
+				
 				/* space handler scriptlinks */
 				lib_link_scriptlink(fd, &sc->id, &sa->scriptlink);
-
+				
 				for (sl= sa->spacedata.first; sl; sl= sl->next) {
 					if(sl->spacetype==SPACE_VIEW3D) {
 						View3D *v3d= (View3D*) sl;
-
+						
 						v3d->camera= newlibadr(fd, sc->id.lib, v3d->camera);
 						v3d->ob_centre= newlibadr(fd, sc->id.lib, v3d->ob_centre);
-
+						
 						if(v3d->bgpic) {
 							v3d->bgpic->ima= newlibadr_us(fd, sc->id.lib, v3d->bgpic->ima);
 						}
@@ -4081,6 +4108,10 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
 				v3d->bgpic= newdataadr(fd, v3d->bgpic);
 				if(v3d->bgpic)
 					v3d->bgpic->iuser.ok= 1;
+				if(v3d->gpd) {
+					v3d->gpd= newdataadr(fd, v3d->gpd);
+					link_gpencil(fd, v3d->gpd);
+				}
 				v3d->localvd= newdataadr(fd, v3d->localvd);
 				v3d->afterdraw.first= v3d->afterdraw.last= NULL;
 				v3d->clipbb= newdataadr(fd, v3d->clipbb);
@@ -4115,9 +4146,30 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
 			}
 			else if(sl->spacetype==SPACE_NODE) {
 				SpaceNode *snode= (SpaceNode *)sl;
+				
+				if(snode->gpd) {
+					snode->gpd= newdataadr(fd, snode->gpd);
+					link_gpencil(fd, snode->gpd);
+				}
 				snode->nodetree= snode->edittree= NULL;
 				snode->flag |= SNODE_DO_PREVIEW;
 			}
+			else if(sl->spacetype==SPACE_SEQ) {
+				SpaceSeq *sseq= (SpaceSeq *)sl;
+				if(sseq->gpd) {
+					sseq->gpd= newdataadr(fd, sseq->gpd);
+					link_gpencil(fd, sseq->gpd);
+				}
+			}
+			else if(sl->spacetype==SPACE_ACTION) {
+				SpaceAction *sact= (SpaceAction *)sl;
+				
+				/* WARNING: action-editor doesn't have it's own gpencil data! 
+				 * so only adjust pointer, but DON'T LINK
+				 */
+				if (sact->gpd) 
+					sact->gpd= newdataadr(fd, sact->gpd);
+			}
 		}
 
 		sa->v1= newdataadr(fd, sa->v1);
diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c
index ca91f1dc346..b59dd851dfe 100644
--- a/source/blender/blenloader/intern/writefile.c
+++ b/source/blender/blenloader/intern/writefile.c
@@ -112,6 +112,7 @@ Important to know is that 'streaming' has been added to files, for Blender Publi
 #include "DNA_customdata_types.h"
 #include "DNA_effect_types.h"
 #include "DNA_group_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_image_types.h"
 #include "DNA_ipo_types.h"
 #include "DNA_fileglobal_types.h"
@@ -1565,6 +1566,32 @@ static void write_scenes(WriteData *wd, ListBase *scebase)
 	mywrite(wd, MYWRITE_FLUSH, 0);
 }
 
+static void write_gpencil(WriteData *wd, bGPdata *gpd)
+{
+	bGPDlayer *gpl;
+	bGPDframe *gpf;
+	bGPDstroke *gps;
+	
+	/* write gpd data block to file */
+	writestruct(wd, DATA, "bGPdata", 1, gpd);
+	
+	/* write grease-pencil layers to file */
+	for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+		writestruct(wd, DATA, "bGPDlayer", 1, gpl);
+		
+		/* write this layer's frames to file */
+		for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+			writestruct(wd, DATA, "bGPDframe", 1, gpf);
+			
+			/* write strokes */
+			for (gps= gpf->strokes.first; gps; gps= gps->next) {
+				writestruct(wd, DATA, "bGPDstroke", 1, gps);
+				writestruct(wd, DATA, "bGPDspoint", gps->totpoints, gps->points);				
+			}
+		}
+	}
+}
+
 static void write_screens(WriteData *wd, ListBase *scrbase)
 {
 	bScreen *sc;
@@ -1610,11 +1637,12 @@ static void write_screens(WriteData *wd, ListBase *scrbase)
 			sl= sa->spacedata.first;
 			while(sl) {
 				if(sl->spacetype==SPACE_VIEW3D) {
-					View3D *v3d= (View3D*) sl;
+					View3D *v3d= (View3D *) sl;
 					writestruct(wd, DATA, "View3D", 1, v3d);
 					if(v3d->bgpic) writestruct(wd, DATA, "BGpic", 1, v3d->bgpic);
 					if(v3d->localvd) writestruct(wd, DATA, "View3D", 1, v3d->localvd);
 					if(v3d->clipbb) writestruct(wd, DATA, "BoundBox", 1, v3d->clipbb);
+					if(v3d->gpd) write_gpencil(wd, v3d->gpd);
 				}
 				else if(sl->spacetype==SPACE_IPO) {
 					writestruct(wd, DATA, "SpaceIpo", 1, sl);
@@ -1626,7 +1654,9 @@ static void write_screens(WriteData *wd, ListBase *scrbase)
 					writestruct(wd, DATA, "SpaceFile", 1, sl);
 				}
 				else if(sl->spacetype==SPACE_SEQ) {
+					SpaceSeq *sseq= (SpaceSeq *)sl;
 					writestruct(wd, DATA, "SpaceSeq", 1, sl);
+					if(sseq->gpd) write_gpencil(wd, sseq->gpd);
 				}
 				else if(sl->spacetype==SPACE_OOPS) {
 					SpaceOops *so= (SpaceOops *)sl;
@@ -1689,7 +1719,9 @@ static void write_screens(WriteData *wd, ListBase *scrbase)
 					writestruct(wd, DATA, "SpaceTime", 1, sl);
 				}
 				else if(sl->spacetype==SPACE_NODE){
+					SpaceNode *snode= (SpaceNode *)sl;
 					writestruct(wd, DATA, "SpaceNode", 1, sl);
+					if(snode->gpd) write_gpencil(wd, snode->gpd);
 				}
 				sl= sl->next;
 			}
diff --git a/source/blender/freestyle/FRS_freestyle.h b/source/blender/freestyle/FRS_freestyle.h
new file mode 100644
index 00000000000..060ccf6961a
--- /dev/null
+++ b/source/blender/freestyle/FRS_freestyle.h
@@ -0,0 +1,15 @@
+#ifndef FRS_FREESTYLE_H
+#define FRS_FREESTYLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif	
+	
+	void FRS_prepare(Render* re);
+	void FRS_execute(Render* re, int render_in_layer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/source/blender/freestyle/SConscript b/source/blender/freestyle/SConscript
new file mode 100644
index 00000000000..12b649c362d
--- /dev/null
+++ b/source/blender/freestyle/SConscript
@@ -0,0 +1,126 @@
+#!/usr/bin/python
+import sys
+Import ('env')
+
+sources = []
+defs = []
+incs = ''
+
+incs += '../blenkernel ../blenlib ../imbuf ../makesdna ../python '
+incs += '../render/extern/include ../render/intern/include ../include ../src'
+incs += ' #/extern/freestyle/lib3ds' 
+incs += ' ' + env['BF_PYTHON_INC']
+incs += ' ' + env['BF_LIB3DS_INC']
+incs += ' ' + env['BF_PNG_INC']
+
+########################################################
+#	folders sources 
+########################################################
+
+#	system
+prefix = 'intern/system'
+system_sources = env.Glob(prefix + '/*.cpp')
+
+#	image
+prefix = 'intern/image'
+image_sources = env.Glob(prefix + '/*.cpp')
+
+#	geometry
+prefix = 'intern/geometry'
+geometry_sources = env.Glob(prefix + '/*.cpp')
+
+#	scene_graph
+prefix = 'intern/scene_graph'
+scene_graph_sources = env.Glob(prefix + '/*.cpp')
+
+#	winged_edge
+prefix = 'intern/winged_edge'
+winged_edge_sources = env.Glob(prefix + '/*.cpp')
+
+#	view_map
+prefix = 'intern/view_map'
+view_map_sources = env.Glob(prefix + '/*.cpp')
+
+#	stroke
+prefix = 'intern/stroke'
+stroke_sources = env.Glob(prefix + '/*.cpp')
+
+#	rendering
+prefix = 'intern/rendering'
+rendering_sources = env.Glob(prefix + '/GL*.cpp')
+
+if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw'):
+	rendering_sources = env.Glob(prefix + '/extgl.cpp')
+
+# 	app / app_blender
+prefix = 'intern/app_blender'
+app_sources = env.Glob(prefix + '/*.cpp')
+
+#	Python
+prefix = 'intern/python'
+# python_sources = env.Glob(prefix + '/*.cpp')
+python_sources = [
+					prefix + '/Freestyle.cpp',
+					prefix + '/Convert.cpp',
+					prefix + '/BinaryPredicate0D.cpp',
+					prefix + '/BinaryPredicate1D.cpp',
+					prefix + '/Id.cpp',
+					prefix + '/IntegrationType.cpp',
+					prefix + '/Interface0D.cpp',
+					prefix + '/Interface0D/CurvePoint.cpp',
+					prefix + '/Interface0D/CurvePoint/StrokeVertex.cpp',
+					prefix + '/Interface0D/SVertex.cpp',
+					prefix + '/Interface0D/ViewVertex.cpp',
+					prefix + '/Interface1D.cpp',
+					prefix + '/Interface1D/FEdge.cpp',
+					prefix + '/Interface1D/Stroke.cpp',
+					prefix + '/Nature.cpp',
+					prefix + '/MediumType.cpp',
+					prefix + '/StrokeAttribute.cpp',
+					prefix + '/StrokeShader.cpp',
+					prefix + '/UnaryFunction0D.cpp',
+					prefix + '/UnaryFunction1D.cpp',
+					prefix + '/UnaryPredicate0D.cpp',
+					prefix + '/UnaryPredicate1D.cpp',
+				]
+
+sources = 	system_sources + image_sources + geometry_sources + scene_graph_sources \
+		  +	winged_edge_sources + view_map_sources + stroke_sources + rendering_sources \
+		  + app_sources + python_sources
+
+env.BlenderLib (libname="bf_freestyle",
+				sources=sources,
+                includes=Split(incs),
+                defines=defs,
+				libtype=['blender'],
+                priority = [25]
+ )
+
+########################################################
+# SWIG
+########################################################
+#	swig
+#
+# 	1] Run the following three commands in the source/blender/freestyle/intern/swig directory.
+#
+#	2] Replace /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/build/darwin/lib to the path
+#	of your library directory (used to locate libbf_freestyle.a)
+#
+#   3] Replace the python directories to suit your config
+
+# export SWIG_LIB=/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/extern/freestyle/swig/Lib
+
+# cd /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/intern/swig
+
+# /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/build/darwin/bin/swig -c++ -python -o ModuleWrapper.cpp Freestyle.i
+
+# mv ./Freestyle.py ../../python/
+
+# g++ -w  -I../geometry -I../image -I../scene_graph -I../stroke -I../system -I../view_map -I../winged_edge -I/usr/include/python2.5 -I../../../blenlib -I../../../blenkernel -I../../../imbuf -I../../../makesdna -c ModuleWrapper.cpp -o ModuleWrapper.o
+
+###########  Mac OS X ###########
+# g++ -bundle -flat_namespace -undefined suppress  -w  -L/usr/lib/python2.5/config -L/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/build/darwin/lib -lpython2.5 -lbf_freestyle -o ../../python/_Freestyle.so ModuleWrapper.o
+
+###########  Linux  ###########
+# g++ -shared -w  -L/usr/lib/python2.5/config -L/home/joe/bf_blender_freestyle/build/linux2/lib  -lpython2.5 -lbf_freestyle -o ../../python/_Freestyle.so ModuleWrapper.o
+
diff --git a/source/blender/freestyle/intern/app/AppAboutWindow.cpp b/source/blender/freestyle/intern/app/AppAboutWindow.cpp
new file mode 100755
index 00000000000..d20e3f4e1ac
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppAboutWindow.cpp
@@ -0,0 +1,36 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <qmessagebox.h>
+#include "AppConfig.h"
+#include "AppAboutWindow.h"
+
+void AppAboutWindow::display() {
+  QMessageBox* mb;
+  
+  mb = new QMessageBox("About " + Config::APPLICATION_NAME,
+						Config::ABOUT_STRING,
+						QMessageBox::NoIcon,
+                        QMessageBox::Ok | QMessageBox::Default, QMessageBox::NoButton, QMessageBox::NoButton,
+						NULL,
+						(Qt::WFlags)(Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::WA_DeleteOnClose));
+  mb->show();
+}
diff --git a/source/blender/freestyle/intern/app/AppAboutWindow.h b/source/blender/freestyle/intern/app/AppAboutWindow.h
new file mode 100755
index 00000000000..ee04d27ae71
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppAboutWindow.h
@@ -0,0 +1,40 @@
+//
+//  Filename         : AppAboutWindow.h
+//  Author           : Emmanuel Turquin
+//  Purpose          : Class to display a "About" window
+//  Date of creation : 13/06/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  APPABOUTWINDOWS_H
+# define APPABOUTWINDOWS_H
+
+class AppAboutWindow
+{
+ public:
+
+  static void display();
+};
+
+#endif // APPABOUTWINDOWS_H
diff --git a/source/blender/freestyle/intern/app/AppCanvas.cpp b/source/blender/freestyle/intern/app/AppCanvas.cpp
new file mode 100755
index 00000000000..3ca06fddfe7
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppCanvas.cpp
@@ -0,0 +1,404 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AppGLWidget.h"
+#include "../image/Image.h"
+#include "../system/TimeStamp.h"
+#include "Controller.h"
+#include "../stroke/StrokeRenderer.h"
+#include "AppCanvas.h"
+#include "../rendering/GLRenderer.h"
+#include "../rendering/GLStrokeRenderer.h"
+#include "../rendering/GLUtils.h"
+#include "AppConfig.h"
+#include <QImage>
+
+#ifdef WIN32
+# include <windows.h>
+# include "../rendering/extgl.h"
+#endif
+#ifdef __MACH__
+# include <OpenGL/gl.h>
+#else
+# include <GL/gl.h>
+#endif
+
+AppCanvas::AppCanvas()
+:Canvas()
+{
+  _pViewer = 0;
+  _blendEquation = true;
+  _MapsPath = (const char*)(Config::Path::getInstance()->getMapsDir().toAscii().data());
+}
+
+AppCanvas::AppCanvas(AppGLWidget* iViewer)
+:Canvas()
+{
+  _pViewer = iViewer;
+  _blendEquation = true;
+}
+
+AppCanvas::AppCanvas(const AppCanvas& iBrother)
+:Canvas(iBrother)
+{
+  _pViewer = iBrother._pViewer;
+  _blendEquation = iBrother._blendEquation;
+}
+
+AppCanvas::~AppCanvas()
+{
+  _pViewer = 0;
+}
+
+void AppCanvas::setViewer(AppGLWidget *iViewer)
+{
+  _pViewer = iViewer;
+}  
+
+int AppCanvas::width() const 
+{
+  return _pViewer->width();
+}
+
+int AppCanvas::height() const
+{
+  return _pViewer->height();
+}
+
+BBox<Vec3r> AppCanvas::scene3DBBox() const 
+{
+  return _pViewer->scene3DBBox();
+}
+
+void AppCanvas::preDraw()
+{
+  Canvas::preDraw();
+
+  _pViewer->prepareCanvas();
+  glClearColor(0,0,0,0);
+	glClear(GL_COLOR_BUFFER_BIT);
+	glDisable(GL_LIGHTING);
+	glPolygonMode(GL_FRONT, GL_FILL);
+	glShadeModel(GL_SMOOTH);
+	glDisable(GL_DEPTH_TEST);
+	glEnable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+}
+
+void AppCanvas::init() 
+{
+#ifdef WIN32
+  static bool firsttime = true;
+  if (firsttime)
+    {
+      if (extgl_Initialize() != 0)
+	      cerr << "Error: problem occurred while initializing GL extensions" << endl;			
+      else
+	      cout << "GL extensions initialized" << endl;
+
+      if(!glutils_extgl_GetProcAddress("glBlendEquation")){
+        _blendEquation = false;
+        cout << "glBlendEquation unavailable on this hardware -> switching to strokes basic rendering mode" << endl;
+      }
+      firsttime=false;
+    }
+#endif
+
+  _Renderer = new GLStrokeRenderer;
+  if(!StrokeRenderer::loadTextures())
+    {
+      cerr << "unable to load stroke textures" << endl;
+      return;
+    }
+}
+
+void AppCanvas::postDraw()
+{
+  //inverse frame buffer
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+  _pViewer->releaseCanvas();
+
+  Canvas::postDraw();
+}
+
+void AppCanvas::Erase()
+{
+  Canvas::Erase();
+  //_pViewer->clear();
+}
+
+#include "../image/GaussianFilter.h"
+void AppCanvas::readColorPixels(int x,int y,int w, int h, RGBImage& oImage) const
+{
+  //static unsigned number = 0;
+  float *rgb = new float[3*w*h];
+  _pViewer->readPixels(x,y,w,h,AppGLWidget::RGB,rgb);
+  oImage.setArray(rgb, width(), height(), w,h, x, y, false);
+  // FIXME
+  //  QImage qtmp(w, h, 32);
+  //  for(unsigned py=0;py<h;++py){
+  //    for(unsigned px=0;px<w;++px){
+  //      int r = (int)255*(oImage.getR(x+px,y+py));
+  //      int g = (int)255*(oImage.getG(x+px,y+py));
+  //      int b = (int)255*(oImage.getB(x+px,y+py));
+  //      qtmp.setPixel(px,py,qRgb(r,g,b));
+  //    }
+  //  }
+  //  qtmp.save("densityQuery"+QString::number(number)+".png", "PNG");
+  //  if(number == 1090){
+  //    RGBImage img;
+  //    float *rgbtmp = new float[3*width()*height()];
+  //    _pViewer->readPixels(0,0,width(),height(),AppGLWidget::RGB,rgbtmp);
+  //    img.setArray(rgbtmp, width(), height(), width(), height(), 0, 0, false);
+  //    QImage qtmp(width(), height(), 32);
+  //    for(unsigned py=0;py<height();++py){
+  //      for(unsigned px=0;px<width();++px){
+  //        int r = (int)255*(img.getR(px,py));
+  //        int g = (int)255*(img.getG(px,py));
+  //        int b = (int)255*(img.getB(px,py));
+  //        qtmp.setPixel(px,height()-1-py,qRgb(r,g,b));
+  //      }
+  //    }
+  //    qtmp.save("densityQuery"+QString::number(number)+".png", "PNG");
+  //    
+  //    GaussianFilter filter;
+  //    filter.setSigma(4.0);
+  //    int bound = filter.getBound();
+  //    QImage qtmp2(width(), height(), 32);
+  //    for(int py2=0;py2<height();++py2){
+  //      for(int px2=0;px2<width();++px2){  
+  //        if( (px2-bound < 0) || (px2+bound>width())
+  //	      || (py2-bound < 0) || (py2+bound>height()))
+  //          continue;
+  //        int g = 255*filter.getSmoothedPixel<RGBImage>(&img, px2,py2);
+  //        qtmp2.setPixel(px2,height()-1-py2,qRgb(g,g,g));
+  //      }
+  //    }
+  //    qtmp2.save("blurredCausalDensity"+QString::number(number)+".png", "PNG");
+  //  }
+  //  cout << number << endl;
+  //  ++number;
+}
+
+void AppCanvas::readDepthPixels(int x,int y,int w, int h, GrayImage& oImage) const
+{
+  float *rgb = new float[w*h];
+  _pViewer->readPixels(x,y,w,h,AppGLWidget::DEPTH,rgb);
+  oImage.setArray(rgb, width(), height(), w,h, x, y, false);
+}
+
+void AppCanvas::update()
+{
+//  static int counter = 0;
+//  char fileName[100] = "framebuffer";
+//  char number[10];
+//
+  _pViewer->updateGL();
+  _pViewer->swapBuffers();
+  //QImage fb = _pViewer->grabFrameBuffer();
+  //  sprintf(number, "%3d", counter);
+  //  strcat(fileName, number);
+  //  strcat(fileName, ".bmp");
+  //  fb.save(fileName, "BMP");
+  //counter++;
+}
+
+void AppCanvas::Render(const StrokeRenderer *iRenderer)
+{
+  if(!_blendEquation){
+    RenderBasic(iRenderer);
+    return;
+  }
+
+  glClearColor(1,1,1,1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  
+  if(_pViewer->draw3DsceneEnabled())
+  {
+    glClearColor(1,1,1,0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    
+    glEnable(GL_LIGHTING);
+    glEnable(GL_DEPTH_TEST);
+    _pViewer->set3DContext();
+    _pViewer->DrawScene(_pViewer->glRenderer());
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_LIGHTING);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+  }
+  
+  
+  glDisable(GL_DEPTH_TEST);
+  glBlendEquation(GL_ADD);
+  
+  glBlendFunc(GL_DST_COLOR, GL_ZERO);
+  
+  if(_drawPaper)
+  {
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    float zfar = _pViewer->zfar();
+    zfar = zfar+0.1*zfar;
+    //draw background paper // FIXME
+    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glBindTexture(GL_TEXTURE_2D, StrokeRenderer::_textureManager->getPaperTextureIndex(_paperTextureIndex)); 
+    glColor4f(1,1,1,0.0);
+    glBegin(GL_TRIANGLE_STRIP);
+    { 
+      glTexCoord2f(0,0); glVertex3f(0, 0, -1);
+      glTexCoord2f(4,0); glVertex3f(2048, 0, -1);
+      glTexCoord2f(0,4); glVertex3f(0, 2048, -1);
+      glTexCoord2f(4,4); glVertex3f(2048, 2048, -1);
+    } 
+    glEnd();
+  }
+  
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glBlendEquation(GL_FUNC_SUBTRACT);
+  glBlendFunc(GL_ONE, GL_ONE);
+  
+  glDisable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+  glColor4f(1,1,1,1);
+  glBegin(GL_TRIANGLE_STRIP);
+  {  
+    glVertex2f(0, 0);
+    glVertex2f(2048, 0);
+    glVertex2f(0, 2048);
+    glVertex2f(2048, 2048);
+  }  
+  glEnd();
+  glPopAttrib();
+  
+  glDisable(GL_DEPTH_TEST);
+  glBlendEquation(GL_ADD);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+  
+  glEnable(GL_TEXTURE_2D);
+  Canvas::Render(iRenderer);
+  //  
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glBlendEquation(GL_FUNC_SUBTRACT);
+  glBlendFunc(GL_ONE, GL_ONE);
+  
+  glDisable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+  glColor3f(1,1,1);
+  glBegin(GL_TRIANGLE_STRIP);
+  { 
+    glVertex2f(0, 0);
+    glVertex2f(2048, 0);
+    glVertex2f(0, 2048);
+    glVertex2f(2048, 2048);
+  } 
+  glEnd();
+  glPopAttrib();
+  
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+}
+
+void AppCanvas::RenderBasic(const StrokeRenderer *iRenderer)
+{
+  glClearColor(1,1,1,1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  
+  if(_pViewer->draw3DsceneEnabled())
+  {
+    glClearColor(1,1,1,0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    
+    glEnable(GL_LIGHTING);
+    glEnable(GL_DEPTH_TEST);
+    _pViewer->set3DContext();
+    _pViewer->DrawScene(_pViewer->glRenderer());
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_LIGHTING);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+  }
+
+  glBlendFunc(GL_DST_COLOR, GL_ZERO);
+  if(_drawPaper)
+  {
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    float zfar = _pViewer->zfar();
+    zfar = zfar+0.1*zfar;
+    //draw background paper // FIXME
+    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glBindTexture(GL_TEXTURE_2D, StrokeRenderer::_textureManager->getPaperTextureIndex(_paperTextureIndex)); 
+    glColor4f(1,1,1,0.0);
+    glBegin(GL_TRIANGLE_STRIP);
+    { 
+      glTexCoord2f(0,0); glVertex3f(0, 0, -1);
+      glTexCoord2f(4,0); glVertex3f(2048, 0, -1);
+      glTexCoord2f(0,4); glVertex3f(0, 2048, -1);
+      glTexCoord2f(4,4); glVertex3f(2048, 2048, -1);
+    } 
+    glEnd();
+  }
+
+  glDisable(GL_DEPTH_TEST);
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glEnable(GL_BLEND);
+  glPopAttrib();
+
+  glDisable(GL_DEPTH_TEST);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+  
+  glEnable(GL_TEXTURE_2D);
+  Canvas::RenderBasic(iRenderer);
+
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+}
+
+
+void AppCanvas::RenderStroke(Stroke *iStroke) {
+  iStroke->Render(_Renderer);
+  if(_pViewer->getRecordFlag()){
+    //Sleep(1000);
+     _pViewer->saveSnapshot(true);
+  }
+}
diff --git a/source/blender/freestyle/intern/app/AppCanvas.h b/source/blender/freestyle/intern/app/AppCanvas.h
new file mode 100755
index 00000000000..be02c02eab7
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppCanvas.h
@@ -0,0 +1,84 @@
+#ifndef ARTCANVAS_H
+#define ARTCANVAS_H
+
+//------------------------------------------------------------------------------------------//
+//
+//                        FileName          : AppCanvas.h
+//                        Author            : Stephane Grabli
+//                        Purpose           : Class to define the App Canvas.
+//                        Date Of Creation  : 05/01/2003
+//
+//------------------------------------------------------------------------------------------//
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../stroke/Canvas.h"
+
+class AppGLWidget;
+class AppCanvas : public Canvas
+{
+private:
+  mutable AppGLWidget *_pViewer;
+  bool _blendEquation;
+public:
+  AppCanvas();
+  AppCanvas(AppGLWidget *iViewer);
+  AppCanvas(const AppCanvas& iBrother);
+  virtual ~AppCanvas();
+
+  /*! operations that need to be done before a draw */
+  virtual void preDraw();
+  
+  /*! operations that need to be done after a draw */
+  virtual void postDraw();
+  
+  /*! Erases the layers and clears the canvas */
+  virtual void Erase(); 
+  
+  /* init the canvas */
+  virtual void init();
+  
+  /*! Reads a pixel area from the canvas */
+  virtual void readColorPixels(int x,int y,int w, int h, RGBImage& oImage) const;
+  /*! Reads a depth pixel area from the canvas */
+  virtual void readDepthPixels(int x,int y,int w, int h, GrayImage& oImage) const;
+
+  virtual BBox<Vec3r> scene3DBBox() const ;
+
+  /*! update the canvas (display) */
+  virtual void update() ;
+
+  /*! Renders the created strokes */
+  virtual void Render(const StrokeRenderer *iRenderer);
+  virtual void RenderBasic(const StrokeRenderer *iRenderer);
+  virtual void RenderStroke(Stroke *iStroke) ;
+
+  /*! accessors */
+  virtual int width() const ;
+  virtual int height() const ;
+  inline const AppGLWidget * viewer() const {return _pViewer;}
+
+  /*! modifiers */
+  void setViewer(AppGLWidget *iViewer) ;
+};
+
+
+#endif
diff --git a/source/blender/freestyle/intern/app/AppConfig.cpp b/source/blender/freestyle/intern/app/AppConfig.cpp
new file mode 100755
index 00000000000..217f58ee806
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppConfig.cpp
@@ -0,0 +1,120 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AppConfig.h"
+#include <iostream>
+using namespace std;
+namespace Config{
+  Path* Path::_pInstance = 0;
+  Path::Path(){
+    // get the home directory
+    _HomeDir = getEnvVar("HOME");
+    // get the root directory
+    setRootDir(getEnvVar("FREESTYLE_DIR"));
+    //setRootDir(QString("."));
+    _pInstance = this;
+  }
+  void Path::setRootDir(const QString& iRootDir){
+    _ProjectDir = iRootDir;
+    _ModelsPath = "";
+    _PatternsPath = _ProjectDir +
+					     QString(DIR_SEP.c_str()) +
+					     "data" +
+					     QString(DIR_SEP.c_str()) +
+					     "textures" +
+					     QString(DIR_SEP.c_str()) +
+					     "variation_patterns" +
+					     QString(DIR_SEP.c_str());
+    _BrushesPath = _ProjectDir +
+					     QString(DIR_SEP.c_str()) +
+					     "data" +
+					     QString(DIR_SEP.c_str()) +
+					     "textures" +
+					     QString(DIR_SEP.c_str()) +
+					     "brushes" +
+					     QString(DIR_SEP.c_str());
+    _PythonPath = _ProjectDir + 
+              QString(DIR_SEP.c_str()) + 
+              "python" + 
+              QString(PATH_SEP.c_str()) +
+              _ProjectDir +
+					    QString(DIR_SEP.c_str()) +
+              "style_modules" +
+              QString(DIR_SEP.c_str()) ;
+    if (getenv("PYTHONPATH")) {
+      _PythonPath += QString(PATH_SEP.c_str()) + QString(getenv("PYTHONPATH"));
+    }
+#ifdef WIN32
+    _BrowserCmd = "C:\\Program Files\\Internet Explorer\\iexplore.exe %s";
+#else
+    _BrowserCmd = "mozilla %s";
+#endif
+    _HelpIndexPath = _ProjectDir +
+					  QString(DIR_SEP.c_str()) +
+					  "doc" +
+					  QString(DIR_SEP.c_str()) +
+					  "html" +
+					  QString(DIR_SEP.c_str()) +
+					  "index.html";
+    _PapersDir = _ProjectDir +
+					  QString(DIR_SEP.c_str()) +
+					  "data" +
+					  QString(DIR_SEP.c_str()) +
+					  "textures" +
+					  QString(DIR_SEP.c_str()) +
+					  "papers" +
+					  QString(DIR_SEP.c_str());
+    _EnvMapDir = _ProjectDir +
+				   QString(DIR_SEP.c_str()) +
+				   "data" +
+				   QString(DIR_SEP.c_str()) +
+				   "env_map" +
+				   QString(DIR_SEP.c_str());
+    _MapsDir = _ProjectDir +
+				   QString(DIR_SEP.c_str()) +
+				   "data" +
+           QString(DIR_SEP.c_str()) +
+				   "maps" +
+				   QString(DIR_SEP.c_str());
+  }
+  void Path::setHomeDir(const QString& iHomeDir){
+    _HomeDir = iHomeDir;
+  }
+  Path::~Path(){
+    _pInstance = 0;
+  }
+  Path* Path::getInstance() {
+    return _pInstance;
+  }
+  QString Path::getEnvVar(const QString& iEnvVarName){
+    QString value;
+    if (!getenv(iEnvVarName.toAscii().data())) {
+      cerr << "Warning: You may want to set the $"<< iEnvVarName.toAscii().data()
+		  << " environment variable to use " << QString(Config::APPLICATION_NAME).toAscii().data() << "." << endl
+	    << "         Otherwise, the current directory will be used instead." << endl;
+      value = ".";
+    }else{
+      value = getenv(iEnvVarName.toAscii().data());
+    } 
+    return value;
+  }
+
+} // End of namepace Config
+
diff --git a/source/blender/freestyle/intern/app/AppConfig.h b/source/blender/freestyle/intern/app/AppConfig.h
new file mode 100755
index 00000000000..54e00571275
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppConfig.h
@@ -0,0 +1,125 @@
+//
+//  Filename         : AppConfig.h
+//  Author           : Emmanuel Turquin
+//  Purpose          : Configuration file
+//  Date of creation : 26/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  APP_CONFIG_H
+# define APP_CONFIG_H
+
+# include <qstring.h>
+# include "../system/FreestyleConfig.h"
+# include "../system/Precision.h"
+
+using namespace std;
+
+namespace Config {
+
+  class Path{
+  protected:
+    static Path * _pInstance;
+    QString _ProjectDir;
+    QString _ModelsPath;
+    QString _PatternsPath;
+    QString _BrushesPath;
+    QString _PythonPath;
+    QString _BrowserCmd;
+    QString _HelpIndexPath;
+    QString _PapersDir;
+    QString _EnvMapDir;
+    QString _MapsDir;
+    QString _HomeDir;
+  public:
+    Path();
+    virtual ~Path();
+    static Path* getInstance();
+
+    void setRootDir(const QString& iRootDir) ;
+    void setHomeDir(const QString& iHomeDir) ;
+
+    const QString& getProjectDir() const {return _ProjectDir;}
+    const QString& getModelsPath() const {return _ModelsPath;}
+    const QString& getPatternsPath() const {return _PatternsPath;}
+    const QString& getBrushesPath() const {return _BrushesPath;}
+    const QString& getPythonPath() const {return _PythonPath;}
+    const QString& getBrowserCmd() const {return _BrowserCmd;}
+    const QString& getHelpIndexpath() const {return _HelpIndexPath;}
+    const QString& getPapersDir() const {return _PapersDir;}
+    const QString& getEnvMapDir() const {return _EnvMapDir;}
+    const QString& getMapsDir() const {return _MapsDir;}
+    const QString& getHomeDir() const {return _HomeDir;}
+
+    static QString getEnvVar(const QString& iEnvVarName);
+    
+  };
+
+  //
+  // Configuration, default values
+  //
+  //////////////////////////////////////////////////////////////
+
+  // Application
+  static const QString APPLICATION_NAME(APPNAME);
+  static const QString APPLICATION_VERSION(APPVERSION);
+
+  // ViewMap
+  static const QString VIEWMAP_EXTENSION("vm");
+  static const QString VIEWMAP_MAGIC("ViewMap File");
+  static const QString VIEWMAP_VERSION("1.9");
+
+  // Style modules
+  static const QString STYLE_MODULE_EXTENSION("py");
+  static const QString STYLE_MODULES_LIST_EXTENSION("sml");
+
+  // Options
+  static const QString OPTIONS_DIR("." + APPLICATION_NAME);
+  static const QString OPTIONS_FILE("options.xml");
+  static const QString OPTIONS_CURRENT_DIRS_FILE("current_dirs.xml");
+  static const QString OPTIONS_QGLVIEWER_FILE("qglviewer.xml");
+
+  // Default options
+  static const real DEFAULT_SPHERE_RADIUS = 1.0;
+  static const real DEFAULT_DKR_EPSILON = 0.0;
+
+  // Papers
+  static const QString DEFAULT_PAPER_TEXTURE("whitepaper.jpg");
+
+  // Help & About texts
+  static const QString HELP_FILE("help.html");
+  static const QString ABOUT_STRING
+    (
+     "<CENTER><H2>" + APPLICATION_NAME + " " + APPLICATION_VERSION + "</H2>"
+     "<P>A programmable line drawing system</P></CENTER>"
+     "<UL>"
+     "<LI>Frédo Durand"
+     "<LI>Stéphane Grabli"
+     "<LI>François Sillion"
+     "<LI>Emmanuel Turquin"
+     "</UL>"
+     "<CENTER><B>(C) Artis 2003</B></CENTER>"
+     );
+
+} // End of namepace Config
+
+#endif // APP_CONFIG_H
diff --git a/source/blender/freestyle/intern/app/AppDensityCurvesWindow.cpp b/source/blender/freestyle/intern/app/AppDensityCurvesWindow.cpp
new file mode 100755
index 00000000000..ec7ee004bf3
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppDensityCurvesWindow.cpp
@@ -0,0 +1,65 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "AppDensityCurvesWindow.h"
+#include "../scene_graph/NodeGroup.h"
+#include "AppGL2DCurvesViewer.h"
+#include <vector>
+using namespace std;
+
+
+AppDensityCurvesWindow::AppDensityCurvesWindow(QWidget *parent, const char *name, bool modal, Qt::WFlags fl)
+ : QDialog(parent, fl)
+{
+	setupUi(this);
+}
+AppDensityCurvesWindow::~AppDensityCurvesWindow(){ 
+}
+
+void AppDensityCurvesWindow::setOrientationCurve(int i, const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iCurve, const char *xlabel, const char *ylabel){
+  AppGL2DCurvesViewer * viewer = 0;
+  switch(i){
+  case 0:viewer = CurvesViewer0; break;
+  case 1:viewer = CurvesViewer1; break;
+  case 2:viewer = CurvesViewer2; break;
+  case 3:viewer = CurvesViewer3; break;
+  case 4:viewer = CurvesViewer4; break;
+  default:return;
+  }
+  
+  viewer->setCurve(vmin, vmax, iCurve, xlabel, ylabel);
+}
+
+void AppDensityCurvesWindow::setLevelCurve(int i, const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iCurve, const char *xlabel, const char *ylabel){
+  AppGL2DCurvesViewer * viewer = 0;
+  switch(i){
+  case 1:viewer = LevelCurveViewer1; break;
+  case 2:viewer = LevelCurveViewer2; break;
+  case 3:viewer = LevelCurveViewer3; break;
+  case 4:viewer = LevelCurveViewer4; break;
+  case 5:viewer = LevelCurveViewer5; break;
+  case 6:viewer = LevelCurveViewer6; break;
+  case 7:viewer = LevelCurveViewer7; break;
+  case 8:viewer = LevelCurveViewer8; break;
+  default:return;
+  }
+  
+  viewer->setCurve(vmin, vmax, iCurve, xlabel, ylabel);
+}
diff --git a/source/blender/freestyle/intern/app/AppDensityCurvesWindow.h b/source/blender/freestyle/intern/app/AppDensityCurvesWindow.h
new file mode 100755
index 00000000000..2fda4da49d9
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppDensityCurvesWindow.h
@@ -0,0 +1,85 @@
+//
+//  Filename         : AppDensityCurvesWindow.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class to define the density curves display window
+//  Date of creation : 14/03/04
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  APPDENSITYCURVESWINDOW_H
+# define APPDENSITYCURVESWINDOW_H
+
+#include "ui_dir/ui_densitycurveswindow4.h"
+#include <vector>
+#include "../geometry/Geom.h"
+using namespace std;
+using namespace Geometry;
+using namespace Ui;
+
+class NodeGroup;
+
+class AppDensityCurvesWindow : public QDialog, public DensityCurvesWindow
+{
+Q_OBJECT
+public:
+	AppDensityCurvesWindow(QWidget *parent = 0, const char *name = 0, bool modal = FALSE, Qt::WFlags fl = 0);
+  virtual ~AppDensityCurvesWindow();
+
+  /*! Sets the node that contains the orientation curve i in 
+   *  viewer i (among 5).
+   *  \param i
+   *    The number of the viewer where the curve must be displayed.(0<=i<5).
+   *  \param vmin
+   *    The x,y min of the curve
+   *  \param vmax
+   *    The x,y max of the curve
+   *  \param iCurve
+   *    The array of XYZ coordinates of the points.
+   *  \param xlabel
+   *    The label of the x-axis
+   *  \param ylabel
+   *    The label of the y-axis
+   */
+  void setOrientationCurve(int i, const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iCurve, const char *xlabel, const char *ylabel);
+
+  /*! Sets the node that contains the level curve i in 
+   *  viewer i (i in [1,8]).
+   *  \param i
+   *    The number of the viewer where the curve must be displayed.(0<=i<5).
+   *  \param vmin
+   *    The x,y min of the curve
+   *  \param vmax
+   *    The x,y max of the curve
+   *  \param iCurve
+   *    The array of XYZ coordinates of the points.
+   *  \param xlabel
+   *    The label of the x-axis
+   *  \param ylabel
+   *    The label of the y-axis
+   */
+  void setLevelCurve(int i, const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iCurve, const char *xlabel, const char *ylabel);
+};
+
+#endif // APPDENSITYCURVESWINDOW_H
+
+
diff --git a/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.cpp b/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.cpp
new file mode 100755
index 00000000000..c5ff7ef6a71
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.cpp
@@ -0,0 +1,152 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AppGL2DCurvesViewer.h"
+#include "../rendering/GLRenderer.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/LineRep.h"
+#include "../scene_graph/VertexRep.h"
+
+AppGL2DCurvesViewer::AppGL2DCurvesViewer(QWidget *iParent, const char *iName)
+: QGLViewer(iParent)
+{
+  _RootNode.setLightingEnabled(false);
+  _RootNode.setLineWidth(1.0);
+  _pGLRenderer = new GLRenderer;
+}
+AppGL2DCurvesViewer::~AppGL2DCurvesViewer(){
+  makeCurrent();
+  _RootNode.destroy();
+  if(_pGLRenderer)
+    delete _pGLRenderer;
+}
+  
+void AppGL2DCurvesViewer::setRange(const Vec2d& vmin, const Vec2d& vmax, const char * xlabel, const char *ylabel){
+  _vmin = vmin;
+  _vmax = vmax;
+  _xmargin = (vmax.x()-vmin.x())/20.0;
+  _ymargin = (vmax.y()-vmin.y())/20.0;
+  _left = vmin.x()-_xmargin;
+  _right = vmax.x()+_xmargin;
+  _bottom = vmin.y()- _ymargin;
+  _top = vmax.y()+_ymargin;
+  if(xlabel)
+    _xlabel = xlabel;
+  if(ylabel)
+    _ylabel = ylabel;
+}
+void AppGL2DCurvesViewer::setCurve(const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iPoints, const char *xlabel, const char *ylabel){
+  setRange(vmin, vmax, xlabel, ylabel);
+  vector<Node*> nodes;
+  _RootNode.RetrieveChildren(nodes);
+  _RootNode.DetachChildren();
+  for(vector<Node*>::iterator n=nodes.begin(), nend=nodes.end();
+  n!=nend;
+  ++n){
+    delete (*n);
+  }
+  _curve.clear();
+  _curve = iPoints;
+  NodeGroup * curveNode = new NodeGroup;
+  NodeShape * shape = new NodeShape;
+  shape->material().setDiffuse(0,0,0,1);
+  curveNode->AddChild(shape);
+  shape->AddRep(new LineRep(iPoints));
+  for(vector<Vec3r>::const_iterator v=iPoints.begin(), vend=iPoints.end();
+  v!=vend;
+  ++v){
+    shape->AddRep(new VertexRep(v->x(), v->y(), v->z()));
+  }
+  _RootNode.AddChild(curveNode);
+  updateGL();
+}
+
+void AppGL2DCurvesViewer::AddNode(Node* iNode){
+  _RootNode.AddChild(iNode);
+}
+
+void AppGL2DCurvesViewer::DetachNode(Node* iNode){
+  _RootNode.DetachChild(iNode);
+}
+
+void AppGL2DCurvesViewer::RetrieveNodes(vector<Node*>& oNodes){
+  _RootNode.RetrieveChildren(oNodes);
+}
+
+void AppGL2DCurvesViewer::init(){
+  glClearColor(1,1,1,1);
+  _left = 0;
+  _right = width();
+  _bottom = 0; 
+  _top = height();
+}
+void AppGL2DCurvesViewer::draw(){
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+//    // Projection Matrix
+//    //==================
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glOrtho(_left,_right, _bottom, _top, -1.0, 1.0);
+
+  //Modelview Matrix
+  //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glDisable(GL_DEPTH_TEST);
+  // draw axis
+  glColor3f(0.5, 0.5, 0.5);
+  // x axis
+  glBegin(GL_LINES);
+  glVertex2f(_left, _vmin.y());
+  glVertex2f(_vmax.x(), _vmin.y());
+  glEnd();
+  QFont serifFont( "Times", 8);
+  if(!_xlabel.isEmpty()){
+    renderText(width()-30, height()-1, _xlabel, serifFont);
+    //renderText(_vmax.x()-_xmargin, _vmin.y(), 0, _xlabel, serifFont);
+  }
+
+  // y axis
+  glBegin(GL_LINES);
+  glVertex2f(_vmin.x(), _bottom);
+  glVertex2f(_vmin.x(), _vmax.y());
+  glEnd();
+  if(!_ylabel.isEmpty()){
+    //renderText(_vmin.x(), _vmax.y()-3*_ymargin, _ylabel, serifFont);
+    renderText(12, 10, _ylabel, serifFont);
+  }
+  _RootNode.accept(*_pGLRenderer);
+  serifFont.setPointSize(7);
+  for(vector<Vec3r>::iterator v=_curve.begin(), vend=_curve.end();
+  v!=vend;
+  ++v){
+    if(v->y() == 0)
+      continue;
+    QString label = QString( "(%1, %2)" )
+                    .arg( (int)v->x())
+                    .arg( v->y(), 0, 'E', 1 );
+
+    renderText(v->x(), v->y(), 0, label, serifFont);
+  }
+  glPopAttrib();
+
+}
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.h b/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.h
new file mode 100755
index 00000000000..2bdefba2a90
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppGL2DCurvesViewer.h
@@ -0,0 +1,80 @@
+//
+//  Filename         : AppGL2DCurvesViewer.h
+//  Author           : Stephane Grabli
+//  Purpose          : 2D GL Curves viewer
+//  Date of creation : 14/03/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  APPGL2DCURVESVIEWER_H
+# define APPGL2DCURVESVIEWER_H
+
+# include <QGLViewer/qglviewer.h>
+# include "../scene_graph/NodeDrawingStyle.h"
+# include <qstring.h>
+
+class GLRenderer;
+
+class AppGL2DCurvesViewer : public QGLViewer
+{
+  Q_OBJECT
+    
+public:
+
+  AppGL2DCurvesViewer(QWidget *iParent, const char *iName = 0);
+  virtual ~AppGL2DCurvesViewer();
+  
+  /*! Sets the ranges.
+   */
+  void setRange(const Vec2d& vmin, const Vec2d& vmax, const char * xlabel, const char *ylabel);
+  void setCurve(const Vec2d& vmin, const Vec2d& vmax, const vector<Vec3r>& iPoints, const char *xlabel, const char *ylabel);
+  void AddNode(Node* iNode);
+  void DetachNode(Node* iNode);
+  void RetrieveNodes(vector<Node*>& oNodes);
+  
+  virtual QSize sizeHint() const {return QSize(200,200);}
+  virtual QSizePolicy sizePolicy() const {return QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);}
+protected:
+    virtual void init();
+    virtual void draw();
+
+private:
+  NodeDrawingStyle _RootNode;
+  GLRenderer     *_pGLRenderer;
+  vector<Vec3r> _curve;
+  Vec2d _vmin; // curve bbox min
+  Vec2d _vmax; // curve bbox max
+  double _left; // frustum clipping planes (slightly differemt from the bbox for a clear view)
+  double _right;
+  double _bottom;
+  float _xmargin; // margin around plot in x direction
+  float _ymargin; // margin around plot in y direction
+  double _top;
+  QString _xlabel;
+  QString _ylabel;
+  
+};
+
+
+#endif // APPGL2DCURVESVIEWER_H
+
diff --git a/source/blender/freestyle/intern/app/AppGLWidget.cpp b/source/blender/freestyle/intern/app/AppGLWidget.cpp
new file mode 100755
index 00000000000..46e1f409cb2
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppGLWidget.cpp
@@ -0,0 +1,1049 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include <qtextstream.h>
+#include <qimage.h>
+#include <qtabwidget.h>
+#include <qtextedit.h>
+#include <QMouseEvent>
+#include "../stroke/Canvas.h"
+#include "AppGLWidget.h"
+#include "../scene_graph/NodeLight.h"
+#include "../rendering/GLRenderer.h"
+#include "../rendering/GLSelectRenderer.h"
+#include "../rendering/GLBBoxRenderer.h"
+#include "../rendering/GLMonoColorRenderer.h"
+#include "Controller.h"
+#include "../view_map/Silhouette.h"
+#include "../view_map/ViewMap.h"
+#include "../scene_graph/LineRep.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/VertexRep.h"
+#include "AppConfig.h"
+
+// glut.h must be included last to avoid a conflict with stdlib.h on vc .net 2003 and 2005
+#ifdef __MACH__
+# include <GLUT/glut.h>
+#else
+# include <GL/glut.h>
+#endif
+
+GLuint texture = 0;
+
+bool AppGLWidget::_frontBufferFlag = false;
+bool AppGLWidget::_backBufferFlag = true;
+
+AppGLWidget::AppGLWidget(QWidget *iParent, const char *iName)
+  : QGLViewer(iParent)
+{
+  _Fovy        = 30.f;
+  //_SceneDepth = 2.f;
+  _RenderStyle = LINE;
+  //_ModelRootNode->setBBox(BBox<Vec3f>(Vec3f(-10.f, -10.f, -10.f), Vec3f(10.f, 10.f, 10.f)));
+  _ModelRootNode = new NodeDrawingStyle;
+  _SilhouetteRootNode = new NodeDrawingStyle;
+  _DebugRootNode = new NodeDrawingStyle;
+  
+  _RootNode.AddChild(_ModelRootNode);
+  _SilhouetteRootNode->setStyle(DrawingStyle::LINES);
+  _SilhouetteRootNode->setLightingEnabled(false);
+  _SilhouetteRootNode->setLineWidth(2.f);
+  _SilhouetteRootNode->setPointSize(3.f);
+
+  _RootNode.AddChild(_SilhouetteRootNode);
+
+  _DebugRootNode->setStyle(DrawingStyle::LINES);
+  _DebugRootNode->setLightingEnabled(false);
+  _DebugRootNode->setLineWidth(1.f);
+  
+  _RootNode.AddChild(_DebugRootNode);
+
+  _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+  _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+
+  _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+  _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+
+  camera()->setZNearCoefficient(0.1);
+
+  // 2D Scene
+  //  _pFENode = new NodeDrawingStyle;
+  //  _pFENode->setStyle(DrawingStyle::LINES);
+  //  _pFENode->setLightingEnabled(false);
+  //  _pFENode->setLineWidth(1.f);
+  //
+  //  _p2DNode.AddChild(_pFENode);
+  //  
+  //  _pVisibleSilhouetteNode = new NodeDrawingStyle;
+  //  _pVisibleSilhouetteNode->setStyle(DrawingStyle::LINES);
+  //  _pVisibleSilhouetteNode->setLightingEnabled(false);
+  //  _pVisibleSilhouetteNode->setLineWidth(3.f);
+  //
+  //  _p2DNode.AddChild(_pVisibleSilhouetteNode);
+  //  
+  _p2DSelectionNode = new NodeDrawingStyle;
+  _p2DSelectionNode->setLightingEnabled(false);
+  _p2DSelectionNode->setStyle(DrawingStyle::LINES);
+  _p2DSelectionNode->setLineWidth(5.f);
+  
+  _p2DNode.AddChild(_p2DSelectionNode);
+
+  _pGLRenderer = new GLRenderer;
+  _pSelectRenderer = new GLSelectRenderer;
+  _pBBoxRenderer = new GLBBoxRenderer;
+  _pMonoColorRenderer = new GLMonoColorRenderer;
+  _pDebugRenderer = new GLDebugRenderer;
+
+  _pMainWindow = NULL;
+  _cameraStateSaved = false;
+  _drawBBox = false;
+  _silhouette = false;
+  _fedges = false;
+  _debug = false;
+  _selection_mode = false;
+  _Draw2DScene = true;
+  _Draw3DScene = true;
+  _drawEnvMap = false;
+  _currentEnvMap = 1;
+  _maxId = 0;
+  _blendFunc = 0;
+
+  const QString sep(Config::DIR_SEP.c_str());
+  const QString filename = Config::Path::getInstance()->getHomeDir() + sep +
+    Config::OPTIONS_DIR + sep + Config::OPTIONS_QGLVIEWER_FILE;
+  setStateFileName(filename);  
+
+  //get camera frame:
+  qglviewer::Camera * cam = camera();
+  qglviewer::ManipulatedFrame *  fr = cam->frame() ;
+  _enableUpdateSilhouettes = false;
+  connect(fr, SIGNAL(modified()), this, SLOT(updateSilhouettes()));
+  _captureMovie = false;
+  //  _frontBufferFlag = false;
+  //  _backBufferFlag = true;
+  _record = false;
+}
+
+AppGLWidget::~AppGLWidget()
+{
+  int ref = _RootNode.destroy();
+  
+  _Light.destroy();
+  ref = _p2DNode.destroy();
+  
+  if(NULL != _pGLRenderer)
+    {
+      delete _pGLRenderer;
+      _pGLRenderer = NULL;
+    }
+
+  if(NULL != _pSelectRenderer)
+    {
+      delete _pSelectRenderer;
+      _pSelectRenderer = NULL;
+    }
+
+  if(NULL != _pBBoxRenderer)
+    {
+      delete _pBBoxRenderer;
+      _pBBoxRenderer = NULL;
+    }
+
+  if(NULL != _pMonoColorRenderer)
+    {
+      delete _pMonoColorRenderer;
+      _pMonoColorRenderer = NULL;
+    }
+
+  if(NULL != _pDebugRenderer)
+    {
+      delete _pDebugRenderer;
+      _pDebugRenderer = NULL;
+    }
+
+  makeCurrent();
+  //saveToFile(filename);
+}
+
+void AppGLWidget::setMainWindow(QMainWindow *iMainWindow) {
+	_pMainWindow = iMainWindow;
+}
+void AppGLWidget::captureMovie()
+{
+  _captureMovie = true;
+  setSnapshotFormat("BMP");
+  setSnapshotFileName("anim");
+  camera()->playPath(0);
+  //_captureMovie = false;
+}
+
+void
+AppGLWidget::updateSilhouettes()
+{
+  if(!_enableUpdateSilhouettes || !g_pController)
+    return;
+  g_pController->ComputeViewMap();
+  g_pController->DrawStrokes();
+  if(_captureMovie)
+  {
+    if(!camera()->keyFrameInterpolator(0)->interpolationIsStarted())
+    {
+      _captureMovie = false;
+      return;
+    }
+    saveSnapshot(true);
+  }
+}
+
+void
+AppGLWidget::select(const QMouseEvent *e) {
+
+  // 3D Shape selection
+
+  if (_selection_mode) {
+
+    // Make openGL context current
+    makeCurrent();
+  
+    const unsigned SENSITIVITY = 4;
+    const unsigned NB_HITS_MAX = 64;
+  
+    // Prepare the selection mode
+    static GLuint hits[NB_HITS_MAX];
+  
+    glSelectBuffer(NB_HITS_MAX, hits);
+    glRenderMode(GL_SELECT);
+    glInitNames();
+
+    // Loads the matrices
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    GLint viewport[4];
+    camera()->getViewport(viewport);
+    gluPickMatrix(static_cast<GLdouble>(e->x()), static_cast<GLdouble>(e->y()), SENSITIVITY, SENSITIVITY, viewport);
+
+    // loadProjectionMatrix() first resets the GL_PROJECTION matrix with a glLoadIdentity.
+    // Give false as a parameter in order to prevent this and to combine the matrices.
+    camera()->loadProjectionMatrix(false);
+
+    camera()->loadModelViewMatrix();
+  
+    // Render scene with objects ids
+    _pSelectRenderer->setSelectRendering(true);
+    DrawScene(_pSelectRenderer);
+    glFlush();
+
+    // Get the results
+    GLint nb_hits = glRenderMode(GL_RENDER);
+
+    if (nb_hits <= 0) {
+      _pSelectRenderer->setSelectedId(-1);
+      return;
+    }
+  
+    // Interpret results
+    unsigned int zMin = hits[1];
+    unsigned int selected = hits[3];
+    for (int i=1; i<nb_hits; ++i)
+      if (hits[i*4+1] < zMin)
+	{
+	  zMin = hits[i*4+1];
+	  selected = hits[i*4+3];
+	}
+    _pSelectRenderer->setSelectedId(selected);
+
+    cout << "SHAPE" << endl;
+    cout << "-----" << endl;
+    cout << "Id: " << _pSelectRenderer->getSelectedId() << endl;
+    cout << endl;
+
+    return;
+  }
+
+  // ViewMap selection
+
+  FEdge *fe = g_pController->SelectFEdge(e->x(), height()-e->y());
+  if (!fe)
+    return;
+  ViewEdge * ve = fe->viewedge();
+
+  if (ve) {
+    cout << "VIEWEDGE" << endl;
+    cout << "--------" << endl;
+    cout << "ViewEdge Id: " << ve->getId().getFirst() << ", " << ve->getId().getSecond() << endl;
+    cout << "Shape Id: " << ve->shape_id() << endl;
+    cout << "Nature: " << ve->getNature() << endl;
+    cout << "QI: " << ve->qi() << endl;
+    if(ve->aShape())
+      cout << "Occludee: " << ve->aShape()->getId() << endl;
+    else
+      cout << "Occludee: NULL" << endl ;
+    cout << endl;
+    
+    cout << "FEDGE" << endl;
+    cout << "-----" << endl;
+    cout << "FEdge Id: " << fe->getId().getFirst() << ", " << fe->getId().getSecond() << endl;
+    cout << "Vertex A Id: " << fe->vertexA()->getId() << endl;
+    cout << "Vertex B Id: " << fe->vertexB()->getId() << endl;
+    cout << endl;
+    
+    vector<ViewEdge*> vedges;
+    vedges.push_back(ve);
+    _p2DSelectionNode->AddChild(g_pController->BuildRep(vedges.begin(), vedges.end()));
+    // FEdge
+    LineRep * fedgeRep = new LineRep(fe->vertexA()->point2d(), fe->vertexB()->point2d());
+    fedgeRep->setWidth(3.f);
+    NodeShape * fedgeNode = new NodeShape;
+    fedgeNode->AddRep(fedgeRep);
+    fedgeNode->material().setDiffuse(0.2, 1, 0.2, 1.0);
+    _p2DSelectionNode->AddChild(fedgeNode);
+    //SVertex A
+    Vec3r A(fe->vertexA()->point2d());
+    VertexRep * aVertexRep = new VertexRep(A.x(), A.y(), A.z());
+    aVertexRep->setPointSize(3.f);
+    NodeShape * aVertexNode = new NodeShape;
+    aVertexNode->AddRep(aVertexRep);
+    aVertexNode->material().setDiffuse(1, 0, 0, 1.0);
+    _p2DSelectionNode->AddChild(aVertexNode);
+    // and its fedges
+    const vector<FEdge*>& afedges = fe->vertexA()->fedges();
+    vector<FEdge*>::const_iterator f=afedges.begin(), fend=afedges.end();
+    for(;
+    f!=fend;
+    ++f)
+    {
+      LineRep * lrep = new LineRep((*f)->vertexA()->point2d(), (*f)->vertexB()->point2d());
+      lrep->setWidth(1.f);
+      aVertexNode->AddRep(lrep);
+    }
+    //SVertex B
+    Vec3r B(fe->vertexB()->point2d());
+    VertexRep * bVertexRep = new VertexRep(B.x(), B.y(), B.z());
+    bVertexRep->setPointSize(3.f);
+    NodeShape * bVertexNode = new NodeShape;
+    bVertexNode->AddRep(bVertexRep);
+    bVertexNode->material().setDiffuse(0, 0, 1, 1.0);
+    _p2DSelectionNode->AddChild(bVertexNode);
+    // and its fedges
+    const vector<FEdge*>& bfedges = fe->vertexB()->fedges();
+    f=bfedges.begin();
+    fend=bfedges.end();
+    for(;
+    f!=fend;
+    ++f)
+    {
+      LineRep * lrep = new LineRep((*f)->vertexA()->point2d(), (*f)->vertexB()->point2d());
+      lrep->setWidth(1.f);
+      bVertexNode->AddRep(lrep);
+    }
+
+  }
+}
+
+
+void
+AppGLWidget::mousePressEvent(QMouseEvent *e)
+{
+  _p2DSelectionNode->destroy();
+  if (e->button() == Qt::LeftButton)
+  {
+	  if(e->modifiers() == Qt::ShiftModifier)
+	  {
+	      select(e);
+      }
+	  else if(e->modifiers() == Qt::ControlModifier)
+	  {
+      // Density Observation
+      g_pController->displayDensityCurves(e->x(), height()-1-e->y());
+	    }else{
+      QGLViewer::mousePressEvent(e);
+    }
+    updateGL();
+  }
+  else
+    QGLViewer::mousePressEvent(e);
+}
+
+void
+AppGLWidget::mouseReleaseEvent  (  QMouseEvent *    e  ) 
+{
+  //  if(g_pController)
+  //    g_pController->ComputeViewMap();
+  //  g_pController->DrawStrokes();
+  QGLViewer::mouseReleaseEvent(e);
+}
+
+void
+AppGLWidget::keyPressEvent(QKeyEvent* e)
+{
+  switch (e->key()) {
+
+  case Qt::Key_U:
+    _enableUpdateSilhouettes = !_enableUpdateSilhouettes;
+    break;
+  case Qt::Key_Escape:
+    break;
+  case Qt::Key_V:
+    g_pController->toggleVisibilityAlgo();
+    break;
+  case Qt::Key_R:
+	  if(e->modifiers() == Qt::ShiftModifier){
+      _record = !_record;
+      if(_record){
+        setSnapshotFormat("JPEG");
+        setSnapshotFileName("anim");
+        g_pController->displayMessage("record", true);
+      }else{
+        g_pController->displayMessage("");
+      }
+      
+    }
+    else if(_cameraStateSaved) {
+      setCameraState(_cameraPosition, _cameraOrientation);
+      updateGL();
+    }
+    break;
+  case Qt::Key_M: 
+    _drawEnvMap = !_drawEnvMap ; 
+    updateGL(); break;
+  case Qt::Key_Plus:
+    Canvas::getInstance()->changePaperTexture(true);updateGL();
+    break;
+  case Qt::Key_Minus:
+    Canvas::getInstance()->changePaperTexture(false);updateGL();
+    break;
+  case Qt::Key_P:
+    Canvas::getInstance()->togglePaperTexture();updateGL();
+    break;
+  case Qt::Key_PageUp:
+	  if(e->modifiers() == Qt::ControlModifier)
+      _blendFunc = (_blendFunc + 1) % 2;
+    else {
+      _currentEnvMap++;
+      if(_currentEnvMap > _maxId)
+	_currentEnvMap = 1;
+    }
+    updateGL();
+    break;
+  case Qt::Key_PageDown:
+	  if(e->modifiers() == Qt::ControlModifier)
+      _blendFunc = (_blendFunc + 1) % 2;
+    else {
+      _currentEnvMap--;
+      if(_currentEnvMap < 1)
+	_currentEnvMap = _maxId;
+    }
+    updateGL();
+    break;
+  case Qt::Key_1: _ModelRootNode->setStyle(DrawingStyle::FILLED); updateGL(); break;
+  case Qt::Key_2: _ModelRootNode->setStyle(DrawingStyle::LINES); _ModelRootNode->setLineWidth(1.0); updateGL(); break;
+  case Qt::Key_3: _ModelRootNode->setStyle(DrawingStyle::INVISIBLE); updateGL(); break;
+  case Qt::Key_B:
+    {
+//       if(e->state() == ShiftButton)
+//         {
+//           g_pController->toggleEdgeTesselationNature(Nature::BORDER); updateGL(); break;
+//         }
+//       else
+        {
+          _drawBBox == true ? _drawBBox = false : _drawBBox = true; updateGL(); break;
+        }
+    }
+//   case Key_C:
+//     if(e->state() == ShiftButton)
+//       {
+// 	g_pController->toggleEdgeTesselationNature(Nature::CREASE); updateGL(); break;
+//       }
+//     break;
+  case Qt::Key_S:
+    {
+//       if(e->state() == ShiftButton)
+//         {
+//           g_pController->toggleEdgeTesselationNature(Nature::SILHOUETTE); updateGL(); break;
+//         }
+//       else
+        {
+          _silhouette == true ? _silhouette = false : _silhouette = true; updateGL(); break;
+        }
+    }
+  case Qt::Key_L: 
+    {
+        _selection_mode = !_selection_mode; updateGL(); break;
+    }
+    break;
+  case Qt::Key_E: 
+    {
+        _fedges == true ? _fedges = false : _fedges = true; updateGL(); break;
+    }
+    break;
+  case Qt::Key_D: 
+    {
+      _debug == true ? _debug = false : _debug = true; updateGL();
+    }
+    break;
+  case Qt::Key_F2: _Draw2DScene == true ? _Draw2DScene = false : _Draw2DScene = true; updateGL(); break; 
+  case Qt::Key_F3: _Draw3DScene == true ? _Draw3DScene = false : _Draw3DScene = true; updateGL(); break; 
+  default:
+    QGLViewer::keyPressEvent(e);
+  }
+}
+
+void AppGLWidget::LoadEnvMap(const char *filename)
+{
+  GLuint textureId;
+  GLubyte *data;
+  //sgiImage img;
+  //cout << filename << endl;
+  QImage img(filename, "PNG");
+  QImage glImage = QGLWidget::convertToGLFormat(img);
+  int d = glImage.depth();
+  //data = img.read(filename); // tres beau bleu gris mauve!!
+  // allocate a texture name
+  glGenTextures( 1, &textureId );
+  if(textureId > _maxId)
+    _maxId = textureId;
+
+  // select our current texture
+  glBindTexture( GL_TEXTURE_2D, textureId );
+  
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
+                   GL_NEAREST);
+
+  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, glImage.width(), glImage.height(), 0,
+    GL_RGBA, GL_UNSIGNED_BYTE, glImage.bits() );
+}
+
+void AppGLWidget::help(){
+  emit helpRequired();
+
+  bool resize = false;
+  int width=600;
+  int height=400;
+
+  static QString label[] = {" &Keyboard ", " &Mouse "};
+
+  QTabWidget * hWidget = helpWidget();
+  if (!hWidget){
+    hWidget = new QTabWidget(NULL);
+    hWidget->setWindowTitle("Control Bindings");
+    resize = true;
+    for (int i=0; i<2; ++i){
+	    QTextEdit* tab = new QTextEdit(hWidget);
+	    //tab->setAcceptRichText(true); // FIXME: commented because qt 4.0 is incomplete
+#if QT_VERSION >= 300
+	    tab->setReadOnly(true);
+#endif
+	    hWidget->insertTab(i, tab, label[i]);
+    }
+  }
+
+#if QT_VERSION < 300
+  const int currentPageIndex = hWidget->currentPageIndex();
+#endif
+
+  for (int i=0; i<2; ++i)
+    {
+      QString text;
+      switch (i)
+	{
+	case 0 : text = keyboardString(); break;
+	case 1 : text = mouseString();	  break;
+	default : break;
+	}
+
+#if QT_VERSION < 300
+    hWidget->setCurrentPage(i);
+    QTextEdit* textEdit = (QTextEdit*)(hWidget->currentPage());
+#else
+    hWidget->setCurrentIndex(i);
+    QTextEdit* textEdit = (QTextEdit*)(hWidget->currentWidget());
+#endif
+    textEdit->setHtml(text);
+
+    if (resize && (textEdit->heightForWidth(width) > height))
+	height = textEdit->heightForWidth(width);
+    }
+  
+#if QT_VERSION < 300
+  hWidget->setCurrentPage(currentPageIndex);
+#endif
+
+  if (resize)
+    hWidget->resize(width, height+40); // 40 is tabs' height
+  hWidget->show();
+  hWidget->raise();  
+}
+  
+QString AppGLWidget::helpString() const{
+  QString pdir(Config::Path::getInstance()->getProjectDir());
+  QString text = "<a href=\"" + pdir + "/doc/html/index.html\">help content</a>";
+  return text;
+}
+
+QString AppGLWidget::mouseString() const{
+  QString text("<table border=\"1\" cellspacing=\"0\">\n");
+  text += "<tr bgcolor=\"#eebf00\"><th align=\"center\">Button</th><th align=\"center\">Description</th></tr>\n";
+  text += "<tr><td><b>Shift+Left</b></td><td>If view map exists, selects a view edge.<br> If in selection mode, selects a shape</td></tr>";
+	text += "</table>";
+  text += QGLViewer::mouseString();
+  return text;
+}
+
+QString AppGLWidget::keyboardString() const {
+
+  QString text("<table border=\"1\" cellspacing=\"0\">\n");
+  text += "<tr bgcolor=\"#eebf00\"><th align=\"center\">Key</th><th align=\"center\">Description</th></tr>\n";
+  text += "<tr><td><b>F2</b></td><td>Toggles 2D Scene display</td></tr>";
+  text += "<tr><td><b>F3</b></td><td>Toggles 3D Scene display</td></tr>";
+
+  text += "<tr><td><b>1</b></td><td>Filled display mode</td></tr>";
+  text += "<tr><td><b>2</b></td><td>Lines display mode</td></tr>";
+  text += "<tr><td><b>3</b></td><td>Invisible display mode</td></tr>";
+
+  text += "<tr><td><b>E</b></td><td>Toggles ViewMap display</td></tr>";
+  text += "<tr><td><b>B</b></td><td>Toggles bounding boxes display</td></tr>";
+  text += "<tr><td><b>S</b></td><td>Toggles GL silhouettes display</td></tr>";
+  text += "<tr><td><b>D</b></td><td>Toggles debug information display</td></tr>";
+  text += "<tr><td><b>L</b></td><td>Toggles shape selection mode</td></tr>";
+  text += "<tr><td><b>P</b></td><td>Toggles paper texture display</td></tr>";
+  text += "<tr><td><b>M</b></td><td>Toggles toon shading</td></tr>";
+  text += "<tr><td><b>V</b></td><td>Toggles visibility algorithm</td></tr>";
+
+  text += "<tr><td><b>R</b></td><td>Reset camera to the latest ViewMap computation settings</td></tr>";
+  text += "<tr><td><b>Shift+R</b></td><td>Toggles snapshots mode</td></tr>";
+
+  text += "<tr><td><b>U</b></td><td>Recomputes the ViewMap when the view changes</td></tr>";
+
+  text += "<tr><td><b>+/-</b></td><td>Change paper texture</td></tr>";
+  text += "<tr><td><b>PgUp/PgDn</b></td><td>Changes EnvMap</td></tr>";
+  text += "<tr><td><b>Ctrl+PgUp/PgDn</b></td><td>Changes blending function</td></tr>";
+  text += "</table>";
+  text += QGLViewer::keyboardString();
+  return text;
+}
+
+void AppGLWidget::init()
+{
+  setShortcut(QGLViewer::EXIT_VIEWER, 0);
+//  setShortcut(QGLViewer::DISPLAY_Z_BUFFER, 0);
+  setShortcut(QGLViewer::STEREO, 0);
+  setShortcut(QGLViewer::ANIMATION, 0);
+  setShortcut(QGLViewer::EDIT_CAMERA, 0);
+
+  restoreStateFromFile();
+
+  //trackball().fitBBox(_ModelRootNode->bbox().getMin(), _ModelRootNode->bbox().getMax(), _Fovy);
+
+   glClearColor(1,1,1,0);
+   glShadeModel(GL_SMOOTH);
+  
+   glCullFace(GL_BACK);
+   glEnable(GL_CULL_FACE);
+   glEnable(GL_DEPTH_TEST);
+
+   // open and read texture data
+   Config::Path * cpath = Config::Path::getInstance();
+   QString envmapDir = cpath->getEnvMapDir();
+   LoadEnvMap((envmapDir + QString("gray00.png")).toAscii().data());
+   //LoadEnvMap(Config::ENV_MAP_DIR + "gray01.bmp");
+   LoadEnvMap((envmapDir + QString("gray02.png")).toAscii().data());
+   LoadEnvMap((envmapDir + QString("gray03.png")).toAscii().data());
+   LoadEnvMap((envmapDir + QString("brown00.png")).toAscii().data());
+   glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
+   glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
+
+   // gl settings for Environmental Texturing:
+   glColor3f(1, 1, 1);
+
+   // Use GL auto-computed enviroment texture coordinates
+   //glEnable(GL_TEXTURE_GEN_S);
+   //glEnable(GL_TEXTURE_GEN_T);
+
+   // Bind the texture to use
+   //glBindTexture(GL_TEXTURE_2D,texture);
+   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+   //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+   
+   // parametres de melange
+   //glBlendFunc(GL_ONE, GL_ONE);
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+   //glBlendEquatio(GL_FUNC_ADD);
+     
+   //glEnable(GL_BLEND);
+   NodeLight *light = new NodeLight;
+   _Light.AddChild(light);
+
+   // Change QGLViewer's default shortcut for snapshots
+   setShortcut(QGLViewer::SAVE_SCREENSHOT, Qt::CTRL + Qt::Key_W);
+   //   setShortcutKey (QGLViewer::SAVE_SCREENSHOT, Key_W);
+   //   setShortcutStateKey(QGLViewer::SAVE_SCREENSHOT, ControlButton);
+  
+   cout << "Renderer (GL)    : " << glGetString(GL_RENDERER) << endl
+	<< "Vendor (GL)      : " << glGetString(GL_VENDOR) << endl << endl;
+}
+
+void AppGLWidget::draw()
+{
+  if (true == _Draw3DScene)
+    {
+      if (true == _selection_mode) {
+	_pSelectRenderer->setSelectRendering(false);
+	_pSelectRenderer->resetColor();
+	DrawScene(_pSelectRenderer);
+      } else
+ 	DrawScene(_pGLRenderer);
+  
+      if (true == _silhouette)
+	DrawSilhouette();
+  
+      if (true == _drawBBox) {
+	glPushAttrib(GL_ALL_ATTRIB_BITS);
+	_ModelRootNode->accept(*_pBBoxRenderer);
+	glPopAttrib();
+      }
+
+      if (true == _debug) {
+	glPushAttrib(GL_ALL_ATTRIB_BITS);
+	_DebugRootNode->accept(*_pDebugRenderer);
+	glPopAttrib();
+      }
+    }
+
+  if (true == _Draw2DScene) {
+    Draw2DScene(_pGLRenderer);
+    set3DContext();
+  }
+  if(_record){
+    saveSnapshot(true);
+  }
+   if(_captureMovie)
+  {
+    if(!camera()->keyFrameInterpolator(0)->interpolationIsStarted())
+    {
+      _captureMovie = false;
+      return;
+    }
+    saveSnapshot(true);
+  }
+}
+
+void AppGLWidget::DrawScene(SceneVisitor *iRenderer)
+{
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+  if(_drawEnvMap)
+  {
+    _ModelRootNode->setLightingEnabled(false);
+    glEnable(GL_COLOR_MATERIAL);
+
+    glEnable(GL_TEXTURE_2D);
+    // Bind the texture to use
+    glBindTexture(GL_TEXTURE_2D,_currentEnvMap); 
+    switch(_blendFunc)
+    {
+    case 0:
+      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+      glEnable(GL_BLEND);
+      break;
+    case 1:
+      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) ;
+      glDisable(GL_BLEND);
+      break;
+      //    case 2:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+      //      glEnable(GL_BLEND);
+      //      break;
+      //    case 3:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR); 
+      //      glEnable(GL_BLEND);
+      //      break;
+      //    case 4:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA); 
+      //      glEnable(GL_BLEND);
+      //      break;
+    default:
+      break;
+    }
+
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+  }
+
+  // FIXME
+  //  //_ModelRootNode->setLightingEnabled(true);
+  //  if(_ModelRootNode->style() == DrawingStyle::LINES){
+  //    glPushAttrib(GL_ALL_ATTRIB_BITS);
+  //    //glDisable(GL_COLOR_MATERIAL);
+  //    _ModelRootNode->setStyle(DrawingStyle::FILLED);
+  //    _ModelRootNode->setLightingEnabled(true);
+  //    _ModelRootNode->accept(*iRenderer);  
+  //    _ModelRootNode->setStyle(DrawingStyle::LINES);
+  //    _ModelRootNode->setLightingEnabled(false);
+  //    _ModelRootNode->accept(*iRenderer);  
+  //    glPopAttrib();
+  //  }
+  //  else
+  _ModelRootNode->accept(*iRenderer);
+
+  glDisable(GL_TEXTURE_GEN_S);
+  glDisable(GL_TEXTURE_GEN_T);
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_COLOR_MATERIAL);
+  _ModelRootNode->setLightingEnabled(true);
+
+  if(_fedges == true)
+    _SilhouetteRootNode->accept(*iRenderer);
+
+  // FIXME: deprecated
+//   if(_debug == true)
+//     _DebugRootNode->accept(*iRenderer);
+  
+  glPopAttrib();
+}
+
+void AppGLWidget::prepareCanvas()
+{
+  makeCurrent();
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+  if(_frontBufferFlag){
+    if(_backBufferFlag)
+      glDrawBuffer(GL_FRONT_AND_BACK);
+    else
+      glDrawBuffer(GL_FRONT);
+  }
+  else if(_backBufferFlag)
+    glDrawBuffer(GL_BACK);
+  
+  // Projection Matrix
+  //==================
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  
+  glOrtho(0,width(), 0, height(), -1.0, 1.0);
+  
+  //Modelview Matrix
+  //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+}
+
+void AppGLWidget::releaseCanvas()
+{
+  makeCurrent();
+  glDrawBuffer(GL_BACK);
+  glPopAttrib();
+}
+
+void AppGLWidget::Draw2DScene(SceneVisitor *iRenderer)
+{
+  static bool first = 1;
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+//    // Projection Matrix
+//    //==================
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glOrtho(0,width(), 0, height(), -1.0, 1.0);
+
+//    //Modelview Matrix
+//    //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  //  glBegin(GL_LINE_LOOP);
+  //  glVertex2f(0,0);
+  //  glVertex2f(100,0);
+  //  glVertex2f(100,100);
+  //  glVertex2f(0,100);
+  //  glEnd();
+
+  //glDrawBuffer(GL_FRONT_AND_BACK);
+  // Draw visible silhouette
+  //_pVisibleSilhouetteNode->Render(iRenderer);
+  Canvas * canvas = Canvas::getInstance();
+  if((canvas) && (!canvas->isEmpty()))
+  {
+    if (first)
+    {
+      canvas->init();
+      first = false;
+    }
+    canvas->Render(canvas->renderer());
+  }
+  
+  glLoadIdentity();
+  //  glColor3f(0.f,1.f,0.f);
+  //  glLineWidth(5.f);
+  //glPolygonOffset(0.5f, 0.5f);
+  glPushAttrib(GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_DEPTH_TEST);
+  _p2DSelectionNode->accept(*iRenderer);
+  glPopAttrib();
+  // Draw Feature edges
+  //  if(_fedges == true)
+  //  {
+  //    _pFENode->Render(iRenderer);
+  //  }
+ 
+  glPopAttrib();
+}
+
+void AppGLWidget::DrawSilhouette()
+{
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+  
+  glDepthFunc(GL_LESS);
+  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+  DrawScene(_pMonoColorRenderer);
+
+  glCullFace(GL_FRONT);
+  glDepthFunc(GL_LEQUAL);
+  glEnable(GL_POLYGON_OFFSET_FILL);
+  glLineWidth(3.0);
+  //glPolygonOffset(10.f, 10.f);
+  glPolygonOffset(0.5f, 0.5f);
+ 
+  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+  _pMonoColorRenderer->setColor(0.f, 0.f, 0.f);
+  DrawScene(_pMonoColorRenderer);
+
+  //Restore old context
+  glPopAttrib();
+
+}
+
+void AppGLWidget::ReInitRenderers()
+{
+  // Debug Renderer
+  if(NULL != _pDebugRenderer)
+    _pDebugRenderer->ReInit(rabs(_ModelRootNode->bbox().getMax()[1] -
+				 _ModelRootNode->bbox().getMin()[1]));
+}
+
+void AppGLWidget::setFrontBufferFlag(bool iBool){
+  _frontBufferFlag = iBool;
+}
+bool AppGLWidget::getFrontBufferFlag() {
+  return _frontBufferFlag;
+}
+void AppGLWidget::setBackBufferFlag(bool iBool){
+  _backBufferFlag = iBool;
+}
+bool AppGLWidget::getBackBufferFlag() {
+  return _backBufferFlag;
+}
+
+//void AppGLWidget::DrawLines()
+//{
+//  //Antialiasing:
+//  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+//  glEnable(GL_BLEND);
+//  glEnable(GL_LINE_SMOOTH);
+//  glPolygonMode(GL_FRONT, GL_LINE);
+//
+//  glColor3f(0.f, 0.f, 0.f);
+//  glLineWidth(2.f);
+//
+//  DrawScene();
+//}
+//
+//void AppGLWidget::DrawSurfacic()
+//{
+//  glPolygonMode(GL_FRONT, GL_FILL);
+//  glShadeModel(GL_SMOOTH);
+//  
+//  glEnable(GL_LIGHTING);
+//  glEnable(GL_LIGHT0);
+//
+//  
+//  GLreal diffuseV[] = {0.5, 0.7, 0.5, 1.0};
+//  glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseV);
+//
+//  //glColor3f(0.f, 0.f, 0.f);
+//
+//  DrawScene();
+//
+//  glDisable(GL_LIGHTING);
+//}
+//
+//void AppGLWidget::DrawDepthBuffer()
+//{
+//  GLint w = width();
+//  GLint h = height();
+//
+//  glPolygonMode(GL_FRONT, GL_FILL);
+//  
+//  //Disable the writing in the frame buffer
+//  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+//
+//  //This rendering will only fills the depth buffer
+//  DrawScene();
+//
+//  //Re-enable the frame buffer writing
+//  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+//
+//
+//  GLreal *zPixels = new real[w*h];
+//  GLreal *colorPixels = new real[4*w*h];
+//
+// // glReadBuffer(GL_FRONT); //in reality: glReadBuffer and glDrawBuffer are both set to GL_BACK
+//  glReadPixels(0,0,w, h, GL_DEPTH_COMPONENT, GL_real, (GLreal*)zPixels);
+//
+//  real *tmpZ = zPixels;
+//  real *tmpColor = colorPixels;
+//
+//  for(int i=0; i<h; i++)
+//  {
+//    for(int j=0; j<w; j++)
+//    {
+//      //fprintf(test, " %.5f ", pixels[i*w+j]);
+//      tmpColor[0] = *tmpZ;
+//      tmpColor[1] = *tmpZ;
+//      tmpColor[2] = *tmpZ;
+//      tmpColor[3] = 1.f;
+//
+//      tmpColor += 4;
+//      tmpZ++;
+//    }
+//  }
+//  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+// // glDrawBuffer(GL_FRONT_AND_BACK);
+//  //glRasterPos2i(0, 0);
+//  //glLoadIdentity();
+//  glDrawPixels(w, h, GL_RGBA, GL_real, (GLreal *)colorPixels);
+//    
+//  delete [] zPixels;
+//  delete [] colorPixels;  
+//}
+
diff --git a/source/blender/freestyle/intern/app/AppGLWidget.h b/source/blender/freestyle/intern/app/AppGLWidget.h
new file mode 100755
index 00000000000..844af9f4037
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppGLWidget.h
@@ -0,0 +1,526 @@
+//
+//  Filename         : AppConfig.h
+//  Author           : Stephane Grabli
+//  Purpose          : Configuration file
+//  Date of creation : 26/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ARTGLWIDGET_H
+# define ARTGLWIDGET_H
+
+# ifndef WIN32
+#  include <algorithm>
+using namespace std;
+#  define __min(x,y) (min(x,y))
+#  define __max(x,y) (max(x,y))
+# endif // WIN32
+
+
+# include <qstringlist.h>
+# include "../geometry/Geom.h"
+# include "../geometry/BBox.h"
+# include "../scene_graph/NodeDrawingStyle.h"
+# include "../system/TimeUtils.h"
+# include "../system/Precision.h"
+# include "AppConfig.h"
+# include "../rendering/GLDebugRenderer.h"
+# include <QGLViewer/qglviewer.h>
+
+using namespace Geometry;
+
+typedef enum {SURFACIC, LINE, DEPTHBUFFER} RenderStyle;
+
+class FEdge;
+class QMainWindow;
+class GLRenderer;
+class GLSelectRenderer;
+class GLBBoxRenderer;
+class GLMonoColorRenderer;
+class GLDebugRenderer;
+
+class AppGLWidget : public QGLViewer
+{
+  Q_OBJECT
+    
+public:
+
+  AppGLWidget(QWidget *iParent, const char *iName = 0);
+  ~AppGLWidget();
+
+public slots:
+  virtual void updateSilhouettes();
+  
+public:
+  virtual void help();
+  
+  // captures a frame animation that was previously registered
+  void captureMovie();
+
+  /*! Sets the rendering style.
+        iStyle
+          The style used to render. Can be:
+          SURFACIC    : usual rendering
+          LINES       : line rendering
+          DEPTHBUFFER : grey-levels rendering of the depth buffer
+          */
+  inline void SetRenderStyle(RenderStyle iStyle)
+  {
+    _RenderStyle = iStyle;
+  }
+
+  /*! Sets the model to draw in the viewer 
+   *  iModel
+   *    The Root Node of the model 
+   */
+  inline void SetModel(NodeGroup *iModel)
+  {
+    if(0 != _ModelRootNode->numberOfChildren())
+    {
+      _ModelRootNode->DetachChildren();
+      _ModelRootNode->clearBBox();
+    }
+      
+    AddModel(iModel);
+  }
+
+  /*! Adds a model for displaying in the viewer */
+  inline void AddModel(NodeGroup *iModel) 
+  {
+    _ModelRootNode->AddChild(iModel);
+    
+    _ModelRootNode->UpdateBBox();
+
+    _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+    
+     _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+
+     _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+
+     // DEBUG:
+    ReInitRenderers();
+ 
+  }
+
+  inline void AddSilhouette(NodeGroup* iSilhouette)
+  {
+    _SilhouetteRootNode->AddChild(iSilhouette);
+    //ToggleSilhouette(true);
+    updateGL();
+  }
+
+  inline void Add2DSilhouette(NodeGroup *iSilhouette)
+  {
+    //_pFENode->AddChild(iSilhouette);
+    //ToggleSilhouette(true);
+    updateGL();
+  }
+
+  inline void Add2DVisibleSilhouette(NodeGroup *iVSilhouette)
+  {
+    //_pVisibleSilhouetteNode->AddChild(iVSilhouette);
+    updateGL();
+  }
+
+  inline void SetDebug(NodeGroup* iDebug)
+  {
+    if(0 != _DebugRootNode->numberOfChildren())
+    {
+      _DebugRootNode->DetachChildren();
+      _DebugRootNode->clearBBox();
+    }
+      
+    AddDebug(iDebug);
+  }
+
+  inline void AddDebug(NodeGroup* iDebug)
+  {
+    _DebugRootNode->AddChild(iDebug);
+    updateGL();
+  }
+
+  inline void DetachModel(Node *iModel)
+  {
+    _ModelRootNode->DetachChild(iModel);
+    _ModelRootNode->UpdateBBox();
+    
+    _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+    
+     _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+     _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+  } 
+
+  inline void DetachModel() 
+  {
+    _ModelRootNode->DetachChildren();
+    _ModelRootNode->clearBBox();
+    
+    // 2D Scene
+    //_p2DNode.DetachChildren();
+    //_pFENode->DetachChildren();
+    //_pVisibleSilhouetteNode->DetachChildren();
+    updateGL();
+  }
+
+  inline void DetachSilhouette()
+  {
+    _SilhouetteRootNode->DetachChildren();
+    //_pFENode->DetachChildren();
+    //_pVisibleSilhouetteNode->DetachChildren();
+    _p2DSelectionNode->destroy();
+    //updateGL(); //FIXME
+  }
+
+  inline void DetachVisibleSilhouette()
+  {
+    //_pVisibleSilhouetteNode->DetachChildren();
+    _p2DSelectionNode->destroy();
+    updateGL();
+  }
+
+  inline void DetachDebug()
+  {
+    _DebugRootNode->DetachChildren();
+    updateGL();
+  }
+
+  void SetMainWindow(QMainWindow *iMainWindow) ;
+
+  inline void Set3DContext()
+  {
+    // GL_PROJECTION matrix
+    camera()->loadProjectionMatrix();
+    // GL_MODELVIEW matrix
+    camera()->loadModelViewMatrix();
+  }
+  
+  inline void RetriveModelViewMatrix(float *p)
+  {
+    makeCurrent();
+    glGetFloatv(GL_MODELVIEW_MATRIX, p);
+  }
+  inline void RetriveModelViewMatrix(real *p)
+  {
+    makeCurrent();
+    glGetDoublev(GL_MODELVIEW_MATRIX, p);
+  }
+
+  inline void RetrieveProjectionMatrix(float *p)
+  {
+    makeCurrent();
+    glGetFloatv(GL_PROJECTION_MATRIX, p);
+
+  }
+  inline void RetrieveProjectionMatrix(real *p)
+  {
+    makeCurrent();
+    glGetDoublev(GL_PROJECTION_MATRIX, p);
+
+  }
+
+  inline void RetrieveViewport(int *p)
+  {
+    makeCurrent();
+    glGetIntegerv(GL_VIEWPORT,(GLint *)p);
+  }
+  
+  inline real GetFocalLength() const
+  {
+    real Near =  __max(0.1,(real)(-2.f*_maxAbs+camera()->distanceToSceneCenter()));
+    return Near;
+  }
+
+  inline real GetAspect() const
+  {
+    return ((real) width()/(real) height());
+  }
+
+  inline real GetFovyRadian() const
+  {
+    return _Fovy/180.0 * M_PI;
+  }
+
+  inline real GetFovyDegrees() const
+  {
+    return _Fovy;
+  }
+
+  inline void FitBBox()
+  {
+    qglviewer::Vec min_(_ModelRootNode->bbox().getMin()[0],
+			_ModelRootNode->bbox().getMin()[1],
+			_ModelRootNode->bbox().getMin()[2]);
+    qglviewer::Vec max_(_ModelRootNode->bbox().getMax()[0],
+			_ModelRootNode->bbox().getMax()[1],
+			_ModelRootNode->bbox().getMax()[2]);
+    setSceneBoundingBox(min_, max_);
+    camera()->showEntireScene();
+  }
+  
+  inline void ToggleSilhouette(bool enabled) 
+  {
+    _fedges = enabled;
+    updateGL();
+  }
+  
+  // Reinit the renderers which need to be informed
+  // when a model is added to the scene.
+  void ReInitRenderers();
+
+  inline void SetSelectedFEdge(FEdge* iFEdge) { _pDebugRenderer->setSelectedFEdge(iFEdge); }
+
+  inline GLDebugRenderer* debugRenderer() { return _pDebugRenderer; }
+  inline void toggle3D() { _Draw3DScene == true ? _Draw3DScene = false : _Draw3DScene = true; updateGL();}
+
+  /*! glReadPixels */
+  typedef enum{
+    RGB,
+    DEPTH
+  } PixelFormat;
+  void readPixels(int x,
+                  int y,
+                  int width,
+                  int height,
+                  PixelFormat format,
+                  float *pixels) 
+  {
+    makeCurrent();
+    //glReadBuffer(GL_FRONT); //in reality: glReadBuffer and glDrawBuffer are both set to GL_BACK
+    glReadBuffer(GL_BACK);
+    GLenum glformat;
+    switch(format)
+    {
+    case RGB:
+      glformat = GL_RGB;
+      break;
+    case DEPTH:
+      glformat = GL_DEPTH_COMPONENT;
+      break;
+    default:
+      break;
+    }
+    glReadPixels(x,y,width, height, glformat, GL_FLOAT, (GLfloat*)pixels);
+  }
+
+  void clear() { makeCurrent(); glClear(GL_COLOR_BUFFER_BIT ); }
+
+  void prepareCanvas();
+  void releaseCanvas();
+
+  typedef enum {
+    FRONT,
+    BACK
+  } GLBuffer;
+
+  void setReadPixelsBuffer(int iBuffer) 
+  {
+    makeCurrent();
+    switch(iBuffer)
+    {
+    case FRONT:
+      glReadBuffer(GL_FRONT);
+      break;
+    case BACK:
+      glReadBuffer(GL_BACK);
+      break;
+    default:
+      break;
+    }
+  }
+
+  BBox<Vec3r> scene3DBBox() const { return _ModelRootNode->bbox(); }
+
+  inline real znear() const {
+    //    return __max((float)_maxAbs/5,(float)(-_maxAbs+camera()->distanceToSceneCenter()));
+    return camera()->zNear();
+  }
+  
+  inline real zfar() const {
+    //    return _maxAbs+camera()->distanceToSceneCenter();
+    return camera()->zFar();
+  }
+
+  inline bool draw3DsceneEnabled() const { return _Draw3DScene; }
+
+  inline bool getRecordFlag() const {return _record;}
+
+  void setCameraState(const float* position, const float* orientation) {
+    camera()->setPosition(qglviewer::Vec(position[0], position[1], position[2]));
+    camera()->setOrientation(qglviewer::Quaternion(orientation[0], orientation[1], orientation[2], orientation[3]));
+  }
+
+  void getCameraState(float* position, float* orientation) const {
+    qglviewer::Vec pos = camera()->position();
+    qglviewer::Quaternion orient = camera()->orientation();
+    int i;
+    for(i=0;i<3;++i){
+      position[i] = pos[i];
+    }
+    for(i=0;i<4;++i){
+      orientation[i] = orient[i];
+    }
+  }
+
+  void saveCameraState() {
+    getCameraState(_cameraPosition, _cameraOrientation);
+    _cameraStateSaved = true;
+  }
+
+  void setUpdateMode(bool b) {
+    _enableUpdateSilhouettes = b;
+  }
+
+  bool getUpdateMode() const {
+    return _enableUpdateSilhouettes;
+  }
+  static void setFrontBufferFlag(bool iBool);
+  static bool getFrontBufferFlag();
+  static void setBackBufferFlag(bool iBool);
+  static bool getBackBufferFlag();
+
+  // help
+  virtual QString helpString() const ;
+
+  virtual QString mouseString() const;
+  virtual QString keyboardString() const;
+
+protected:
+  virtual void    mousePressEvent(QMouseEvent *);
+  virtual void    mouseReleaseEvent  (  QMouseEvent *    e  ) ;
+  virtual void    select(const QMouseEvent *);
+  virtual void    keyPressEvent(QKeyEvent* e);
+  virtual void	  init();
+  virtual void    draw();
+
+  /*! Loads an envmap */
+  void LoadEnvMap(const char *filename);
+
+public:
+  /*! Core scene drawing */
+  void            DrawScene(SceneVisitor *iRenderer);
+
+  /*! 2D Scene Drawing */
+  void            Draw2DScene(SceneVisitor *iRenderer);
+
+  /*! Draws scene silhouettes in real time */
+  void            DrawSilhouette();
+  
+  /*! Draws the Scene in lines style */
+  //  void            DrawLines();
+  //  /*! Draws the scene in surfacic style */
+  //  void            DrawSurfacic();
+  //  /*! Draws the scene as a depth buffer image */
+  //  void            DrawDepthBuffer();
+
+  GLRenderer* glRenderer() {return _pGLRenderer;}
+
+protected:
+
+
+  //QString shortcutBindingsString() const;
+
+  /*! fabs or abs */
+  inline int rabs(int x) {return abs(x);}
+  inline real rabs(real x) {return fabs(x);}
+
+  
+protected:
+  float _Fovy;
+  //float _SceneDepth;
+  //BBox<Vec3f> _BBox;
+  
+  RenderStyle _RenderStyle;
+
+  //The root node container
+  NodeGroup        _RootNode;
+  NodeDrawingStyle *_ModelRootNode;
+  NodeDrawingStyle *_SilhouetteRootNode;
+  NodeDrawingStyle *_DebugRootNode;
+  
+  bool _silhouette;
+  bool _fedges;
+  bool _debug;
+  bool _selection_mode;
+
+  //a Universal light:
+  NodeGroup _Light;
+
+  real _minBBox;
+  real _maxBBox;
+  real _maxAbs;
+
+  real _minAbs;
+  bool _drawBBox;
+
+  // OpenGL Renderer
+  GLRenderer *_pGLRenderer;
+  GLSelectRenderer *_pSelectRenderer;
+  GLBBoxRenderer *_pBBoxRenderer;
+  GLMonoColorRenderer *_pMonoColorRenderer;
+  GLDebugRenderer *_pDebugRenderer;
+  
+  QMainWindow *_pMainWindow;
+
+  Chronometer _Chrono;
+
+  // 2D Scene
+  bool _Draw2DScene;
+  bool _Draw3DScene;  NodeGroup _p2DNode;
+  //NodeDrawingStyle *_pFENode; // Feature edges node
+  //NodeDrawingStyle *_pVisibleSilhouetteNode;
+  NodeDrawingStyle *_p2DSelectionNode;
+
+  // EnvMap
+  bool _drawEnvMap;
+  int _currentEnvMap;
+  int _maxId;
+  int _blendFunc;
+
+  // Each time we compute the view map, the camera state is 
+  // saved in order to be able to restore it later
+  bool  _cameraStateSaved;
+  float _cameraPosition[3];
+  float _cameraOrientation[4];
+
+  // interactive silhouette update
+  bool _enableUpdateSilhouettes;
+  //capture movie
+  bool _captureMovie;
+  // 2D drawing buffers
+  static bool _frontBufferFlag;
+  static bool _backBufferFlag;
+
+  bool _record;
+};
+
+#endif // ARTGLWIDGET_H
diff --git a/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.cpp b/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.cpp
new file mode 100755
index 00000000000..b074c85f9f9
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.cpp
@@ -0,0 +1,119 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <QTextEdit>
+#include <QFileDialog>
+#include "AppConfig.h"
+#include "Controller.h"
+#include "AppInteractiveShaderWindow.h"
+#include "QStyleModuleSyntaxHighlighter.h"
+
+AppInteractiveShaderWindow::AppInteractiveShaderWindow(QWidget* parent /* = 0 */, const char* name /* = 0 */, bool modal /* = FALSE */, Qt::WFlags fl /* = 0  */)
+: InteractiveShaderWindow() // parent, name, modal, fl)
+{
+	setupUi(this);
+  _CurrentShaderRow = -1;
+  _syntaxHighlighter = new QStyleModuleSyntaxHighlighter(TextArea);
+	// signals and slots connections
+    connect( CancelButton, SIGNAL( clicked() ), this, SLOT( fileClose() ) );
+    connect( SaveButton, SIGNAL( clicked() ), this, SLOT( fileSave() ) );
+    connect( SaveAsButton, SIGNAL( clicked() ), this, SLOT( fileSaveAs() ) );
+    connect( OkButton, SIGNAL( clicked() ), this, SLOT( fileOk() ) );
+}
+
+AppInteractiveShaderWindow::~AppInteractiveShaderWindow()
+{
+  if(_syntaxHighlighter){
+    delete _syntaxHighlighter;
+  }
+}
+
+void AppInteractiveShaderWindow::fileOk()
+{
+  fileSave();
+  fileClose();
+}
+
+void AppInteractiveShaderWindow::fileClose()
+{
+  TextArea->clear();
+  close();
+}
+
+void AppInteractiveShaderWindow::fileSave()
+{
+  QFile file(_CurrentShader);
+  if ( !file.open( QIODevice::WriteOnly ) )
+    return;
+  QTextStream ts( &file );
+  ts << TextArea->toPlainText();
+
+  file.close();
+  emit save();
+  g_pController->setModified(_CurrentShaderRow, true);
+}
+
+void AppInteractiveShaderWindow::fileSaveAs()
+{
+  QFileInfo fi1(_CurrentShader);
+  QString ext1 = fi1.suffix();
+  QString fn;
+
+  if (ext1 == Config::STYLE_MODULE_EXTENSION)
+    fn = QFileDialog::getSaveFileName(this,
+						"save file dialog"
+				      "Choose a file",
+						g_pController->getModulesDir(),
+				      "Style modules (*." + Config::STYLE_MODULE_EXTENSION + ")");
+  if (!fn.isEmpty() && (_CurrentShader == fn))
+    fileSave();
+  else if (!fn.isEmpty())
+    {
+      QFileInfo fi2(fn);
+      QString ext2 = fi2.suffix();
+      if (ext1 != ext2)
+	fn += "." + ext1;
+      QFile file(fn);
+	  if ( !file.open( QIODevice::WriteOnly ) )
+	return;
+      QTextStream ts( &file );
+      ts << TextArea->toPlainText();
+      file.close();
+      g_pController->AddStyleModule(fn.toAscii().data());
+      g_pController->setModulesDir(fi2.dir().path());
+    }
+}
+
+void AppInteractiveShaderWindow::DisplayShader(QString& iName)
+{
+  _CurrentShader = iName;
+  QFile file( iName);
+  if ( !file.open( QIODevice::ReadOnly ) )
+	  return;
+  
+  QTextStream ts( &file );
+  TextArea->setText( ts.readAll() );
+  TextArea->viewport()->setFocus();
+
+  // Set window title:
+  QFileInfo fi(iName);
+  setWindowTitle(fi.fileName());
+  g_pController->setModulesDir(fi.dir().path());
+}
diff --git a/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.h b/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.h
new file mode 100755
index 00000000000..58f2aa1f01a
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppInteractiveShaderWindow.h
@@ -0,0 +1,73 @@
+#ifndef ARTINTERACTIVESHADERWINDOW_H
+#define ARTINTERACTIVESHADERWINDOW_H
+
+//------------------------------------------------------------------------------------------//
+//
+//                        FileName          : AppInteractiveShaderWindow.h
+//                        Author            : Stephane Grabli
+//                        Purpose           : Class to define the graphic window displaying the interactive shader
+//                        Date Of Creation  : 21/10/2002
+//
+//------------------------------------------------------------------------------------------//
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "ui_dir/ui_interactiveshaderwindow4.h"
+#include <QKeyEvent>
+
+using namespace Ui;
+
+class QStyleModuleSyntaxHighlighter;
+class AppInteractiveShaderWindow : public QDialog, public InteractiveShaderWindow
+{
+  Q_OBJECT
+    public:
+		AppInteractiveShaderWindow(QWidget *parent = 0, const char *name = 0, bool modal = FALSE, Qt::WFlags fl = 0);
+  virtual ~AppInteractiveShaderWindow();
+
+public slots:
+  virtual void fileOk();
+  virtual void fileClose();
+  virtual void fileSave();
+  virtual void fileSaveAs();
+  
+  void DisplayShader(QString& iName);
+  void setCurrentShaderRow(int current) { _CurrentShaderRow = current; }
+  int getCurrentShaderRow() const { return _CurrentShaderRow; }
+
+ signals:
+  void save(  );
+
+ protected:
+
+	 void keyPressEvent(QKeyEvent *e) {
+		 if (e->key() == Qt::Key_Escape)
+	return;
+      QDialog::keyPressEvent(e);
+  }
+
+ private:
+  int _CurrentShaderRow;
+  QString _CurrentShader;
+  QStyleModuleSyntaxHighlighter *_syntaxHighlighter;
+};
+
+#endif
+
diff --git a/source/blender/freestyle/intern/app/AppMainWindow.cpp b/source/blender/freestyle/intern/app/AppMainWindow.cpp
new file mode 100755
index 00000000000..f869eb8e637
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppMainWindow.cpp
@@ -0,0 +1,288 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <QApplication>
+#include <QCursor>
+#include <QProgressDialog>
+#include <QFileDialog>
+#include <QFile>
+#include <QStatusBar>
+#include <QToolBar>
+#include <QToolButton>
+#include <QLayout>
+#include "AppMainWindow.h"
+#include "AppGLWidget.h"
+#include "Controller.h"
+#include "AppConfig.h"
+
+AppMainWindow::AppMainWindow(QWidget *parent, const char *name, Qt::WindowFlags f)
+	: QMainWindow(parent, f)  // parent, name, f)
+{
+	setupUi(this); 
+	pQGLWidget = new AppGLWidget(this);
+	gridLayout->addWidget(pQGLWidget);
+
+  // setCaption(Config::APPLICATION_NAME + " " + Config::APPLICATION_VERSION);
+  setGeometry(20,20,700,700);
+  pQGLWidget->setMainWindow(this);
+
+  _ProgressBar = new QProgressDialog(Config::APPLICATION_NAME + " Progress Dialog", "Cancel", 
+				     0, 100, this);
+	// signals and slots connections
+    connect( actionOpen, SIGNAL( triggered() ), this, SLOT( fileOpen() ) );
+    connect( actionQuit, SIGNAL( triggered() ), this, SLOT( close() ) );
+    connect( actionClose, SIGNAL( triggered() ), this, SLOT( fileClose() ) );
+    connect( actionComputeViewMap, SIGNAL( triggered() ), this, SLOT( ComputeViewMap() ) );
+    connect( actionSave, SIGNAL( triggered() ), this, SLOT( ViewMapFileSave() ) );
+    connect( actionStyleModelerWindow, SIGNAL( triggered() ), this, SLOT( DisplayStylesWindow() ) );
+    connect( actionOptionsWindow, SIGNAL( triggered() ), this, SLOT( DisplayOptionsWindow() ) );
+    connect( actionComputeStrokes, SIGNAL( triggered() ), this, SLOT( ComputeStrokes() ) );
+    connect( actionHelp, SIGNAL( triggered() ), this, SLOT( DisplayHelp() ) );
+    connect( actionSaveSnapshot, SIGNAL( triggered() ), this, SLOT( Snapshot() ) );
+    connect( actionCaptureMovie, SIGNAL( triggered() ), this, SLOT( captureMovie() ) );
+    connect( actionResetInterpreter, SIGNAL( triggered() ), this, SLOT( ResetInterpreter() ) );
+    connect( actionSaveDirectionalViewMapImages, SIGNAL( triggered() ), this, SLOT( SaveDirectionalViewMapImages() ) );
+    connect( actionAbout, SIGNAL( triggered() ), this, SLOT( About() ) );
+    connect( actionLoadCamera, SIGNAL( triggered() ), this, SLOT( loadCamera() ) );
+    connect( actionSavePSSnapshot, SIGNAL( triggered() ), this, SLOT( PSSnapshot() ) );
+    connect( actionSaveTextSnapshot, SIGNAL( triggered() ), this, SLOT( TextSnapshot() ) );
+    connect( actionControlBindings, SIGNAL( triggered() ), pQGLWidget, SLOT( help() ) );
+}
+
+AppMainWindow::~AppMainWindow() {}
+
+void AppMainWindow::fileOpen()
+{
+  QString s = QFileDialog::getOpenFileName(this,
+	  "open file dialog"
+	  "Choose a file",
+	  g_pController->getModelsDir(),
+					   "Scenes (*.3ds *.3DS);;ViewMaps (*." + Config::VIEWMAP_EXTENSION + ")");
+  if ( s.isEmpty() ) {
+    statusBar()->showMessage( "Loading aborted", 2000 );
+    return;
+  }
+
+  QFileInfo fi(s);
+  QString ext = fi.suffix();
+  if ((ext == "3ds") || (ext == "3DS"))
+    {
+      QApplication::setOverrideCursor( Qt::WaitCursor );
+      g_pController->Load3DSFile(s.toAscii().data()); // lunch time...
+      g_pController->setModelsDir(fi.dir().path());
+      QApplication::restoreOverrideCursor();
+    }
+  else if (ext == Config::VIEWMAP_EXTENSION)
+    {
+      QApplication::setOverrideCursor( Qt::WaitCursor );
+      g_pController->LoadViewMapFile(s.toAscii().data()); // ...and now tea time...
+      g_pController->setModelsDir(fi.dir().path());
+      QApplication::restoreOverrideCursor();
+    }
+}
+
+void AppMainWindow::loadCamera()
+{
+  QString s = QFileDialog::getOpenFileName(this,
+						"open file dialog"
+					   "Choose a file",
+						g_pController->getModelsDir(),
+					   "ViewMaps (*." + Config::VIEWMAP_EXTENSION + ")");
+  if ( s.isEmpty() ) {
+    statusBar()->showMessage( "Loading aborted", 2000 );
+    return;
+  }
+
+  QFileInfo fi(s);
+  QString ext = fi.suffix();
+  if (ext == Config::VIEWMAP_EXTENSION)
+    {
+      QApplication::setOverrideCursor( Qt::WaitCursor );
+      g_pController->LoadViewMapFile(s.toAscii().data(), true);
+      QApplication::restoreOverrideCursor();
+    }
+}
+
+void AppMainWindow::ViewMapFileSave() {
+  QString s = QFileDialog::getSaveFileName(this,
+					   "save file dialog"
+					   "Choose a file",
+		g_pController->getModelsDir(),
+					   "ViewMaps (*." + Config::VIEWMAP_EXTENSION + ")");
+  if (s.isEmpty()) {
+    statusBar()->showMessage( "Saving aborted", 2000 );
+    return;
+  }
+
+  QFileInfo fi(s);
+  QString ext = fi.suffix();
+  if(ext != Config::VIEWMAP_EXTENSION)
+    s += "." + Config::VIEWMAP_EXTENSION;
+
+  QApplication::setOverrideCursor( Qt::WaitCursor );
+  g_pController->setModelsDir(fi.dir().path());
+  g_pController->SaveViewMapFile(s.toAscii().data());
+  QApplication::restoreOverrideCursor();
+}
+
+void AppMainWindow::fileClose()
+{
+  g_pController->CloseFile();
+}
+
+void AppMainWindow::DisplayStylesWindow() {
+  g_pController->ExposeStyleWindow();
+}
+
+void AppMainWindow::DisplayOptionsWindow() {
+  g_pController->ExposeOptionsWindow();
+}
+
+void AppMainWindow::DisplayHelp() {
+  g_pController->ExposeHelpWindow();
+}
+
+void AppMainWindow::About() {
+  g_pController->ExposeAboutWindow();
+}
+
+void AppMainWindow::Snapshot() {
+  g_pController->saveSnapshot();
+}
+
+void AppMainWindow::captureMovie() {
+  g_pController->captureMovie();
+}
+
+void AppMainWindow::ResetInterpreter() {
+  g_pController->resetInterpreter();
+}
+
+//void AppMainWindow::BrutForceSilhouette()
+//{
+//  QApplication::setOverrideCursor( Qt::WaitCursor );
+//  g_pController->ComputeSilhouette(Controller::BRUT_FORCE);
+//  QApplication::restoreOverrideCursor();
+//}
+//
+//void AppMainWindow::AppelSilhouette()
+//{
+//  QApplication::setOverrideCursor( Qt::WaitCursor );
+//  g_pController->ComputeSilhouette();
+//  QApplication::restoreOverrideCursor();
+//}
+
+void AppMainWindow::ComputeViewMap()
+{
+  QApplication::setOverrideCursor(Qt::WaitCursor);
+  g_pController->ComputeViewMap();
+  QApplication::restoreOverrideCursor();
+}
+
+void AppMainWindow::SaveDirectionalViewMapImages(){
+  QApplication::setOverrideCursor(Qt::WaitCursor);
+  g_pController->saveSteerableViewMapImages();
+  QApplication::restoreOverrideCursor();
+}
+
+void AppMainWindow::ComputeStrokes()
+{
+  g_pController->DrawStrokes();
+}
+
+//void AppMainWindow::InitProgressBar(const char *title, int numSteps)
+//{
+//  _ProgressBar = new QProgressDialog(title, 0, numSteps, this, "progress", TRUE);
+//  _ProgressBar->show();
+//  _ProgressBar->setProgress(0);
+//}
+//
+//void AppMainWindow::SetProgressLabel(const char *label)
+//{
+//  if(NULL == _ProgressBar)
+//    return;
+//  _ProgressBar->setLabelText(label);
+//}
+//
+//void AppMainWindow::SetProgress(int i)
+//{
+//  _ProgressBar->setProgress(i);
+//  qApp->processEvents();
+//
+//  if(i == _ProgressBar->totalSteps())
+//  {
+//    _ProgressBar->setProgress(_ProgressBar->totalSteps());
+//    delete _ProgressBar;
+//    _ProgressBar = NULL;
+//  }
+//}
+
+void AppMainWindow::DisplayMessage(const char* msg, bool persistent)
+{
+  if(persistent)
+    statusBar()->showMessage( msg);
+  else
+    statusBar()->showMessage( msg, 2000 );
+}
+//void AppMainWindow::toggleSilhouette(bool enabled)
+//{
+//  pQGLWidget->ToggleSilhouette(enabled);
+//}
+
+void AppMainWindow::PSSnapshot() {
+  QString s = QFileDialog::getSaveFileName(this,
+					   "save file dialog"
+					   "Choose a file",
+						g_pController->view()->snapshotFileName(),
+					   "Encapsulated Postscript (*.eps)");
+  if (s.isEmpty()) {
+    statusBar()->showMessage( "Saving aborted", 2000 );
+    return;
+  }
+
+  QFileInfo fi(s);
+  QString ext = fi.suffix();
+  if(ext != "eps")
+    s += ".eps" ;
+
+  QApplication::setOverrideCursor( Qt::WaitCursor );
+  g_pController->savePSSnapshot(s);
+  QApplication::restoreOverrideCursor();
+}
+
+void AppMainWindow::TextSnapshot() {
+  QString s = QFileDialog::getSaveFileName(this,
+						"save file dialog"
+					   "Choose a file",
+						g_pController->getModelsDir(),
+					   "Text File (*.txt)");
+  if (s.isEmpty()) {
+    statusBar()->showMessage( "Saving aborted", 2000 );
+    return;
+  }
+
+  QFileInfo fi(s);
+  QString ext = fi.suffix();
+  if(ext != "txt")
+    s += ".txt" ;
+
+  QApplication::setOverrideCursor( Qt::WaitCursor );
+  g_pController->saveTextSnapshot(s);
+  QApplication::restoreOverrideCursor();
+}
diff --git a/source/blender/freestyle/intern/app/AppMainWindow.h b/source/blender/freestyle/intern/app/AppMainWindow.h
new file mode 100755
index 00000000000..750283f85ba
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppMainWindow.h
@@ -0,0 +1,83 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#ifndef ARTMAINWINDOW_H
+#define ARTMAINWINDOW_H
+
+#include <QKeyEvent>
+#include <QWidget>
+#include <QPainter>
+#include <QColorGroup>
+#include <QToolBar>
+#include <QMainWindow>
+#include "ui_dir/ui_appmainwindowbase4.h"
+
+using namespace Ui;
+
+class QProgressDialog;
+class AppGLWidget;
+class AppMainWindow : public QMainWindow, public AppMainWindowBase
+{
+  Q_OBJECT
+
+public:
+
+	AppMainWindow(QWidget *parent = 0, const char *name = 0, Qt::WindowFlags f = Qt::Window);
+  ~AppMainWindow();
+
+  QToolBar *pTools;
+
+public slots:
+  virtual void fileOpen();
+  virtual void fileClose();
+  virtual void loadCamera();
+  virtual void DisplayStylesWindow();
+  virtual void DisplayOptionsWindow();
+  virtual void DisplayHelp();
+  virtual void About();
+  virtual void ViewMapFileSave();
+  //  virtual void AppelSilhouette();
+  //  virtual void BrutForceSilhouette();
+  virtual void ComputeViewMap();
+  virtual void SaveDirectionalViewMapImages();
+  virtual void ComputeStrokes();
+  virtual void Snapshot();
+  virtual void captureMovie();
+  virtual void ResetInterpreter();
+  virtual void PSSnapshot();
+  virtual void TextSnapshot();
+
+public:
+  //  void InitProgressBar(const char *title, int numSteps)
+  ;
+  //  void SetProgressLabel(const char *label);
+  //  void SetProgress(int i);
+  //  
+  void DisplayMessage(const char* msg, bool persistent = false);
+
+  QProgressDialog * qtProgressDialog() {return _ProgressBar;}
+  AppGLWidget * pQGLWidget;
+
+private:
+  QProgressDialog* _ProgressBar;
+};
+
+
+#endif
diff --git a/source/blender/freestyle/intern/app/AppOptionsWindow.cpp b/source/blender/freestyle/intern/app/AppOptionsWindow.cpp
new file mode 100755
index 00000000000..6c3dc9a83aa
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppOptionsWindow.cpp
@@ -0,0 +1,410 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Must be included before any QT header, because of moc
+#include "../system/PythonInterpreter.h"
+
+#include <QCheckBox>
+#include <QLineEdit>
+#include <QFileDialog>
+#include <QString>
+#include <QStringList>
+#include <QListWidgetItem>
+#include "../stroke/StrokeRenderer.h"
+#include "AppConfig.h"
+#include "Controller.h"
+#include "../view_map/ViewMapIO.h"
+#include "AppOptionsWindow.h"
+
+AppOptionsWindow::AppOptionsWindow(QWidget *parent, const char *name, bool modal, Qt::WFlags fl)
+: QDialog(parent, fl) { // parent, name, modal, fl) {
+
+	setupUi(this);
+  const QString sep(Config::DIR_SEP.c_str());
+  QString filename;
+
+  // Create a ConfigIO object
+  filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR + sep + Config::OPTIONS_FILE;
+  _options = new ConfigIO(filename, Config::APPLICATION_NAME + "Options");
+  _options->loadFile();
+
+  // Set the widgets to correct values
+
+  // -> Directories tab
+  QString str;
+  Config::Path * cpath = Config::Path::getInstance();
+  if (_options->getValue("default_path/models/path", str))
+    str = cpath->getModelsPath();
+  modelsPathLineEdit->setText(str);
+  if (_options->getValue("default_path/patterns/path", str))
+    str = cpath->getPatternsPath();
+  patternsPathLineEdit->setText(str);
+  if (_options->getValue("default_path/brushes/path", str))
+    str = cpath->getBrushesPath();
+  brushesPathLineEdit->setText(str);
+  if (_options->getValue("default_path/python/path", str))
+    str = cpath->getPythonPath();
+  pythonPathLineEdit->setText(str);
+
+  // -> Papers Textures tab
+  unsigned papers_nb;
+  QStringList sl;
+  if (_options->getValue("papers/nb", papers_nb)) {
+    sl.push_back(cpath->getPapersDir() + Config::DEFAULT_PAPER_TEXTURE);
+  } else {
+    for (unsigned i = 0; i < papers_nb; i++) {
+      QString path;
+      QTextStream(&path) << "papers/texture" << i << "/filename";
+      _options->getValue(path, str);
+	  paperTexturesList->insertItem(paperTexturesList->count(), str);
+    }
+  }
+  
+
+  // -> Help tab
+  if (_options->getValue("default_browser/cmd", str))
+    str = cpath->getBrowserCmd();
+  browserCmdLineEdit->setText(str);
+  if (_options->getValue("default_path/help/index", str))
+    str = cpath->getHelpIndexpath();
+  helpIndexPathLineEdit->setText(str);
+
+  // -> Misc tab
+  bool b;
+  if (_options->getValue("default_viewmap_format/float_vectors", b))
+    b = false;
+  asFloatCheckBox->setChecked(b);
+  if (_options->getValue("default_viewmap_format/no_occluders", b))
+    b = false;
+  noOccluderListCheckBox->setChecked(b);
+  if (_options->getValue("default_viewmap_format/compute_steerable", b))
+    b = false;
+  steerableViewMapCheckBox->setChecked(b);
+  if (_options->getValue("default_visibility/exhaustive_computation", b))
+    b = true;
+  qiCheckBox->setChecked(b);
+  if (_options->getValue("default_drawing_buffers/back_buffer", b))
+    b = true;
+  backBufferCheckBox->setChecked(b);
+  if (_options->getValue("default_drawing_buffers/front_buffer", b))
+    b = false;
+  frontBufferCheckBox->setChecked(b);
+  real r;
+  if (_options->getValue("default_ridges/sphere_radius", r))
+    r = Config::DEFAULT_SPHERE_RADIUS;
+  sphereRadiusLineEdit->setText(QString(QString::number(r)));
+  if (_options->getValue("default_ridges/enable", b))
+    b = false;
+  ridgeValleyCheckBox->setChecked(b);
+  if (_options->getValue("default_suggestive_contours/enable", b))
+    b = false;
+  suggestiveContoursCheckBox->setChecked(b);
+  if (_options->getValue("default_suggestive_contours/dkr_epsilon", r))
+    r = Config::DEFAULT_DKR_EPSILON;
+  krEpsilonLineEdit->setText(QString(QString::number(r)));
+
+  // Propagate changes
+  Propagate();
+
+	// signals and slots connections
+    connect( okButton, SIGNAL( clicked() ), this, SLOT( Ok() ) );
+    connect( applyButton, SIGNAL( clicked() ), this, SLOT( Apply() ) );
+    connect( closeButton, SIGNAL( clicked() ), this, SLOT( Cancel() ) );
+    connect( patternsPathAddButton, SIGNAL( clicked() ), this, SLOT( PatternsAdd() ) );
+    connect( modelPathAddButton, SIGNAL( clicked() ), this, SLOT( ModelsAdd() ) );
+    connect( addPaperTextureButton, SIGNAL( clicked() ), this, SLOT( PaperAdd() ) );
+    connect( removePaperTextureButton, SIGNAL( clicked() ), this, SLOT( PaperRemove() ) );
+    connect( moveUpPaperTextureButton, SIGNAL( clicked() ), this, SLOT( PaperUp() ) );
+    connect( moveDownPaperTextureButton, SIGNAL( clicked() ), this, SLOT( PaperDown() ) );
+    connect( clearPaperTextureButton, SIGNAL( clicked() ), this, SLOT( PaperClear() ) );
+    connect( pythonPathAddButton, SIGNAL( clicked() ), this, SLOT( PythonAdd() ) );
+    connect( helpIndexPathButton, SIGNAL( clicked() ), this, SLOT( HelpAdd() ) );
+    connect( brushesPathAddButton, SIGNAL( clicked() ), this, SLOT( BrushesAdd() ) );
+}
+
+AppOptionsWindow::~AppOptionsWindow() {
+  delete _options;
+}
+
+void AppOptionsWindow::Propagate() {
+
+  // Directories
+  ViewMapIO::Options::setModelsPath((const char*)modelsPathLineEdit->text().toAscii().data());
+  PythonInterpreter::Options::setPythonPath((const char*)pythonPathLineEdit->text().toAscii().data());
+  TextureManager::Options::setPatternsPath((const char*)patternsPathLineEdit->text().toAscii().data());
+  TextureManager::Options::setBrushesPath((const char*)brushesPathLineEdit->text().toAscii().data());
+  g_pController->setBrowserCmd(browserCmdLineEdit->text());
+  g_pController->setHelpIndex(helpIndexPathLineEdit->text());
+
+  // ViewMap Format
+  if (asFloatCheckBox->isChecked())
+    ViewMapIO::Options::addFlags(ViewMapIO::Options::FLOAT_VECTORS);
+  else
+    ViewMapIO::Options::rmFlags(ViewMapIO::Options::FLOAT_VECTORS);
+  if (noOccluderListCheckBox->isChecked())
+    ViewMapIO::Options::addFlags(ViewMapIO::Options::NO_OCCLUDERS);
+  else
+    ViewMapIO::Options::rmFlags(ViewMapIO::Options::NO_OCCLUDERS);
+  g_pController->setComputeSteerableViewMapFlag(steerableViewMapCheckBox->isChecked());
+
+  // Visibility
+  if (qiCheckBox->isChecked())
+    g_pController->setQuantitativeInvisibility(true);
+  else
+    g_pController->setQuantitativeInvisibility(false);
+
+  // Papers Textures
+  vector<string> sl;
+  for (unsigned i = 0; i < paperTexturesList->count(); i++) {
+    sl.push_back(paperTexturesList->item(i)->text().toAscii().constData());
+  }
+  TextureManager::Options::setPaperTextures(sl);
+
+   // Drawing Buffers
+  if (frontBufferCheckBox->isChecked())
+    g_pController->setFrontBufferFlag(true);
+  else
+    g_pController->setFrontBufferFlag(false);
+  if (backBufferCheckBox->isChecked())
+    g_pController->setBackBufferFlag(true);
+  else
+    g_pController->setBackBufferFlag(false);
+
+  // Ridges and Valleys
+  g_pController->setComputeRidgesAndValleysFlag(ridgeValleyCheckBox->isChecked());
+  // Suggestive Contours
+  g_pController->setComputeSuggestiveContoursFlag(suggestiveContoursCheckBox->isChecked());
+  bool ok;
+  real r = sphereRadiusLineEdit->text().toFloat(&ok);
+  if(ok)
+    g_pController->setSphereRadius(r);
+  else
+    sphereRadiusLineEdit->setText(QString(QString::number(g_pController->getSphereRadius())));
+  r = krEpsilonLineEdit->text().toFloat(&ok);
+  if(ok)
+    g_pController->setSuggestiveContourKrDerivativeEpsilon(r);
+  else
+    krEpsilonLineEdit->setText(QString(QString::number(g_pController->getSuggestiveContourKrDerivativeEpsilon())));
+}
+
+void AppOptionsWindow::Ok() {
+  Apply();
+  close();
+}
+
+void AppOptionsWindow::Apply() {
+
+  // Propagate changes
+  Propagate();
+
+  // Update values of the Options DOM Tree accordingly
+  _options->setValue("default_path/models/path", modelsPathLineEdit->text());
+  _options->setValue("default_path/patterns/path", patternsPathLineEdit->text());
+  _options->setValue("default_path/brushes/path", brushesPathLineEdit->text());
+  _options->setValue("default_path/python/path", pythonPathLineEdit->text());
+  _options->setValue("default_browser/cmd", browserCmdLineEdit->text());
+  _options->setValue("default_path/help/index", helpIndexPathLineEdit->text());
+  _options->setValue("default_viewmap_format/float_vectors", asFloatCheckBox->isChecked());
+  _options->setValue("default_viewmap_format/no_occluders", noOccluderListCheckBox->isChecked());
+  _options->setValue("default_visibility/exhaustive_computation", qiCheckBox->isChecked());
+  _options->setValue("default_drawing_buffers/front_buffer", frontBufferCheckBox->isChecked());
+  _options->setValue("default_drawing_buffers/back_buffer", backBufferCheckBox->isChecked());
+
+  // -> Papers Textures tab
+  unsigned papers_nb = paperTexturesList->count();
+  _options->setValue("papers/nb", papers_nb);
+  for (unsigned i = 0; i < papers_nb; i++) {
+    QString path;
+    QTextStream(&path) << "papers/texture" << i << "/filename";
+    _options->setValue(path, paperTexturesList->item(i)->text());
+  }
+
+  // -> Help tab
+  _options->setValue("default_browser/cmd", browserCmdLineEdit->text());
+  _options->setValue("default_path/help/index", helpIndexPathLineEdit->text());
+   
+  // -> Misc tab
+  _options->setValue("default_viewmap_format/float_vectors", asFloatCheckBox->isChecked());
+  _options->setValue("default_viewmap_format/no_occluders", noOccluderListCheckBox->isChecked());
+  _options->setValue("default_viewmap_format/compute_steerable", steerableViewMapCheckBox->isChecked());
+  _options->setValue("default_visibility/exhaustive_computation", qiCheckBox->isChecked());
+  _options->setValue("default_drawing_buffers/back_buffer", backBufferCheckBox->isChecked());
+  _options->setValue("default_drawing_buffers/front_buffer", frontBufferCheckBox->isChecked());
+  _options->setValue("default_ridges/enable", ridgeValleyCheckBox->isChecked());
+  _options->setValue("default_suggestive_contours/enable", suggestiveContoursCheckBox->isChecked());
+  bool ok;
+  real r = sphereRadiusLineEdit->text().toFloat(&ok);
+  if(!ok)
+    r = Config::DEFAULT_SPHERE_RADIUS;
+  _options->setValue("default_ridges/sphere_radius", r);
+  r = krEpsilonLineEdit->text().toFloat(&ok);
+  if(!ok)
+    r = Config::DEFAULT_DKR_EPSILON;
+  _options->setValue("default_suggestive_contours/dkr_epsilon", r);
+
+  // Save options to disk
+  _options->saveFile();
+}
+
+void AppOptionsWindow::Cancel() {
+
+  // Directories
+  QString qstr;
+  qstr = ViewMapIO::Options::getModelsPath().c_str();
+  modelsPathLineEdit->setText(qstr);
+  qstr = PythonInterpreter::Options::getPythonPath().c_str();
+  pythonPathLineEdit->setText(qstr);
+  qstr = TextureManager::Options::getPatternsPath().c_str();
+  patternsPathLineEdit->setText(qstr);
+  qstr = TextureManager::Options::getBrushesPath().c_str();
+  brushesPathLineEdit->setText(qstr);
+  qstr = g_pController->getBrowserCmd();
+  browserCmdLineEdit->setText(qstr);
+  qstr = g_pController->getHelpIndex();
+  helpIndexPathLineEdit->setText(qstr);
+
+  // ViewMap Format
+  updateViewMapFormat();
+  steerableViewMapCheckBox->setChecked(g_pController->getComputeSteerableViewMapFlag());
+
+  // Visibility
+  qiCheckBox->setChecked(g_pController->getQuantitativeInvisibility());
+
+  // Drawing buffers
+  frontBufferCheckBox->setChecked(g_pController->getFrontBufferFlag());
+  backBufferCheckBox->setChecked(g_pController->getBackBufferFlag());
+
+  // Ridges and Valleys
+  ridgeValleyCheckBox->setChecked(g_pController->getComputeRidgesAndValleysFlag());
+  // suggestive contours
+  suggestiveContoursCheckBox->setChecked(g_pController->getComputeSuggestiveContoursFlag());
+  sphereRadiusLineEdit->setText(QString::number(g_pController->getSphereRadius()));
+  krEpsilonLineEdit->setText(QString(QString::number(g_pController->getSuggestiveContourKrDerivativeEpsilon())));
+
+  close();
+}
+
+void AppOptionsWindow::updateViewMapFormat() {
+  asFloatCheckBox->setChecked(ViewMapIO::Options::getFlags() & ViewMapIO::Options::FLOAT_VECTORS);
+  noOccluderListCheckBox->setChecked(ViewMapIO::Options::getFlags() & ViewMapIO::Options::NO_OCCLUDERS);
+}
+
+void AppOptionsWindow::ModelsAdd() {
+  QString s = modelsPathLineEdit->text();
+  QString new_s = DirDialog();
+  if (new_s.isEmpty())
+    return;
+  if (!s.isEmpty())
+    s += Config::PATH_SEP.c_str();
+  s += new_s;
+  modelsPathLineEdit->setText(s);
+}
+
+void AppOptionsWindow::PatternsAdd() {
+  QString s = patternsPathLineEdit->text();
+  QString new_s = DirDialog();
+  if (new_s.isEmpty())
+    return;
+  if (!s.isEmpty())
+    s += Config::PATH_SEP.c_str();
+  s += new_s;
+  patternsPathLineEdit->setText(s);
+}
+
+void AppOptionsWindow::BrushesAdd() {
+  QString s = brushesPathLineEdit->text();
+  QString new_s = DirDialog();
+  if (new_s.isEmpty())
+    return;
+  if (!s.isEmpty())
+    s += Config::PATH_SEP.c_str();
+  s += new_s;
+  brushesPathLineEdit->setText(s);
+}
+
+void AppOptionsWindow::PythonAdd() {
+  QString s = pythonPathLineEdit->text();
+  QString new_s = DirDialog();
+  if (new_s.isEmpty())
+    return;
+  if (!s.isEmpty())
+    s += Config::PATH_SEP.c_str();
+  s += new_s;
+  pythonPathLineEdit->setText(s);
+}
+
+void AppOptionsWindow::HelpAdd() {
+  QString s = QFileDialog::getOpenFileName((QWidget *)this,
+	  "Open file dialog"
+					   "Choose a file",
+	  g_pController->getHelpIndex(),
+					   "HTML files (*.html *.htm)");
+  if (s.isEmpty())
+    return;
+  helpIndexPathLineEdit->setText(s);
+}
+
+QString AppOptionsWindow::DirDialog() {
+  QString s = QFileDialog::getExistingDirectory((QWidget *)this,
+						"get existing directory"
+						"Choose a directory",
+						".",
+						QFileDialog::ShowDirsOnly| QFileDialog::DontResolveSymlinks);
+  return s;
+}
+
+void AppOptionsWindow::PaperAdd() {
+  QStringList sl = QFileDialog::getOpenFileNames((QWidget *)this,
+	  "open files dialog"
+						 "Choose a file",
+						 g_pController->getPapersDir(),
+	  "Images (*.bmp *.png *.jpg *.xpm)");
+  paperTexturesList->insertItems(paperTexturesList->count(), sl);
+}
+
+void AppOptionsWindow::PaperRemove() {
+	paperTexturesList->takeItem(paperTexturesList->currentRow());
+}
+
+void AppOptionsWindow::PaperUp() {
+  int current = paperTexturesList->currentRow();
+  if (current < 1)
+    return;
+  QString s = paperTexturesList->currentItem()->text();
+  paperTexturesList->item(current)->setText(paperTexturesList->item(current - 1)->text());
+  paperTexturesList->item(current - 1)->setText(s);
+  paperTexturesList->setCurrentRow(current - 1);
+}
+
+void AppOptionsWindow::PaperDown() {
+	int current = paperTexturesList->currentRow();
+  if (current > paperTexturesList->count() - 2)
+    return;
+  QString s = paperTexturesList->currentItem()->text();
+  paperTexturesList->item(current)->setText(paperTexturesList->item(current + 1)->text());
+  paperTexturesList->item(current + 1)->setText(s);
+  paperTexturesList->setCurrentRow(current + 1);
+}
+
+void AppOptionsWindow::PaperClear() {
+  paperTexturesList->clear();
+}
+
diff --git a/source/blender/freestyle/intern/app/AppOptionsWindow.h b/source/blender/freestyle/intern/app/AppOptionsWindow.h
new file mode 100755
index 00000000000..aaa964739a6
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppOptionsWindow.h
@@ -0,0 +1,74 @@
+//
+//  Filename         : AppOptionsWindow.h
+//  Author           : Emmanuel Turquin, Stephane Grabli
+//  Purpose          : Class to define the options window
+//  Date of creation : 27/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef ARTOPTIONSWINDOW_H
+#define ARTOPTIONSWINDOW_H
+
+#include "ConfigIO.h"
+#include "ui_dir/ui_optionswindow4.h"
+
+using namespace Ui;
+
+class AppOptionsWindow : public QDialog, public OptionsWindow
+{ 
+    Q_OBJECT
+
+public:
+
+	AppOptionsWindow(QWidget *parent = 0, const char *name = 0, bool modal = FALSE, Qt::WFlags fl = 0);
+    ~AppOptionsWindow();
+
+    virtual void updateViewMapFormat();
+
+public slots:
+
+    virtual void Ok();
+    virtual void Apply();
+    virtual void Cancel();
+
+    virtual void ModelsAdd();
+    virtual void PatternsAdd();
+    virtual void BrushesAdd();
+    virtual void PythonAdd();
+    virtual void HelpAdd();
+
+    virtual void PaperAdd();
+    virtual void PaperRemove();
+    virtual void PaperUp();
+    virtual void PaperDown();
+    virtual void PaperClear();
+
+ private:
+
+    virtual QString DirDialog();
+    virtual void Propagate();
+    
+    ConfigIO* _options;
+};
+
+#endif // ARTOPTIONSWINDOW_H
diff --git a/source/blender/freestyle/intern/app/AppProgressBar.cpp b/source/blender/freestyle/intern/app/AppProgressBar.cpp
new file mode 100755
index 00000000000..a4d18d07dd3
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppProgressBar.cpp
@@ -0,0 +1,78 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <qprogressdialog.h>
+#include <qapplication.h>
+#include "AppProgressBar.h"
+
+AppProgressBar::AppProgressBar()
+	: ProgressBar()
+{
+	_qtProgressBar = 0;
+}
+
+void AppProgressBar::reset()
+{
+  ProgressBar::reset();
+  if(NULL == _qtProgressBar)
+    return;
+
+  _qtProgressBar->reset();
+  _qtProgressBar->show();
+}
+
+void AppProgressBar::setTotalSteps(unsigned n)
+{
+  ProgressBar::setTotalSteps(n);
+  if(NULL == _qtProgressBar)
+    return;
+  
+   _qtProgressBar->setRange(0,_numtotalsteps);
+}
+
+void AppProgressBar::setProgress(unsigned i)
+{
+  if(i > _numtotalsteps)
+    return;
+
+  ProgressBar::setProgress(i);
+  if(NULL == _qtProgressBar)
+    return;
+
+  _qtProgressBar->setValue(_progress);
+  qApp->processEvents();
+
+  if(i == _numtotalsteps)
+  {
+    _qtProgressBar->setValue(_numtotalsteps);
+    
+    _qtProgressBar->reset();
+    ProgressBar::reset();
+    _qtProgressBar->hide();
+  }
+}
+
+void AppProgressBar::setLabelText(const string& label)
+{
+  ProgressBar::setLabelText(label);
+  if (NULL == _qtProgressBar)
+    return;
+  _qtProgressBar->setLabelText(_label.c_str());
+}
diff --git a/source/blender/freestyle/intern/app/AppProgressBar.h b/source/blender/freestyle/intern/app/AppProgressBar.h
new file mode 100755
index 00000000000..09cc500a981
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppProgressBar.h
@@ -0,0 +1,55 @@
+#ifndef ARTPROGRESSBAR_H
+#define ARTPROGRESSBAR_H
+
+//
+//
+//                        FileName          : AppProgressBar.h
+//                        Author            : Stephane Grabli
+//                        Purpose           : Class to define the App progress bar
+//                        Date Of Creation  : 27/08/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "../system/ProgressBar.h"
+
+class QProgressDialog;
+class AppProgressBar : public ProgressBar
+{
+public:
+  AppProgressBar();
+
+  virtual ~AppProgressBar() {}
+
+  virtual void reset();
+  virtual void setTotalSteps(unsigned n);
+  virtual void setProgress(unsigned i);
+  virtual void setLabelText(const string& text) ;
+
+  void setQTProgressBar(QProgressDialog* qtBar) {_qtProgressBar = qtBar;}
+
+  QProgressDialog * getQTProgressBar() {return _qtProgressBar;}
+
+private:
+  QProgressDialog *_qtProgressBar;
+};
+
+#endif
diff --git a/source/blender/freestyle/intern/app/AppStyleWindow.cpp b/source/blender/freestyle/intern/app/AppStyleWindow.cpp
new file mode 100755
index 00000000000..d8be753b498
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppStyleWindow.cpp
@@ -0,0 +1,366 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <fstream>
+#include <QCursor>
+#include <QApplication>
+#include <QFileDialog>
+#include <QHeaderView>
+#include <QString>
+#include "AppStyleWindow.h"
+#include "../stroke/Canvas.h"
+#include "../stroke/StyleModule.h"
+#include "Controller.h"
+#include "AppInteractiveShaderWindow.h"
+#include "AppConfig.h"
+
+AppStyleWindow::AppStyleWindow(QWidget* parent /* = 0 */, const char* name /* = 0 */, Qt::WFlags fl /* = 0 */)
+  : QDialog(parent, fl)
+{
+  // QDialog *widget = new QDialog(parent);
+  setupUi(this);
+	PlayList->setShowGrid(false);
+	PlayList->verticalHeader()->setVisible(false);
+	PlayList->horizontalHeader()->setClickable(false);
+	PlayList->setSelectionBehavior(QAbstractItemView::SelectRows);
+	PlayList->setSelectionMode(QAbstractItemView::SingleSelection);
+	PlayList->setColumnCount(5);
+  PlayList->setColumnWidth(0, 37);
+  PlayList->setColumnWidth(1, width() - 98);
+  PlayList->setColumnWidth(2, 37);
+  PlayList->hideColumn(3);
+  PlayList->hideColumn(4);
+  PlayList->setRowCount(0);
+  //PlayList->setsetLeftMargin(0);
+	PlayList->setHorizontalHeaderLabels((QStringList() << "Disp." << "Style Modules" << "Mod."));
+  _pInteractiveShaderWindow = new AppInteractiveShaderWindow(this);
+  _pInteractiveShaderWindow->hide();
+  QString projectDir(Config::Path::getInstance()->getProjectDir());
+  _mod0_image = new QPixmap(QString::fromUtf8(":/icons/icons/mod0.png"));
+  _mod1_image = new QPixmap(QString::fromUtf8(":/icons/icons/mod1.png"));
+  _disp0_image = new QPixmap(QString::fromUtf8(":/icons/icons/eye0.png"));
+  _disp1_image = new QPixmap(QString::fromUtf8(":/icons/icons/eye1.png"));
+
+  connect(_pInteractiveShaderWindow, SIGNAL(save()), SLOT(fileSave()));
+	// signals and slots connections
+    connect( addButton, SIGNAL( clicked() ), this, SLOT( Add() ) );
+    connect( removeButton, SIGNAL( clicked() ), this, SLOT( Remove() ) );
+    connect( PlayList, SIGNAL( cellDoubleClicked(int,int) ), this, SLOT( Display(int,int) ) );
+    connect( PlayList, SIGNAL( cellClicked(int,int) ), this, SLOT( ToggleLayer(int,int) ) );
+    connect( clearButton, SIGNAL( clicked() ), this, SLOT( Clear() ) );
+    connect( saveButton, SIGNAL( clicked() ), this, SLOT( SaveList() ) );
+    connect( moveUpButton, SIGNAL( clicked() ), this, SLOT( Up() ) );
+    connect( moveDownButton, SIGNAL( clicked() ), this, SLOT( Down() ) );
+    connect( editButton, SIGNAL( clicked() ), this, SLOT( Edit() ) );
+    connect( closeButton, SIGNAL( clicked() ), this, SLOT( Close() ) );
+}
+
+AppStyleWindow::~AppStyleWindow()
+{
+  delete _mod0_image;
+  delete _mod1_image;
+  delete _disp0_image;
+  delete _disp1_image;
+}
+
+void AppStyleWindow::Add(const char* iFileName, bool iDisp) {
+  //Add the item in the view box
+  //PlayList->insertItem(fi.fileName());  
+  // PlayList->insertItem(s);
+  int currentRow;
+  QFileInfo fi(iFileName);
+  if(0 == PlayList->rowCount())
+    {
+      currentRow = -1;
+    }
+  else
+    {
+      currentRow = PlayList->currentRow();
+    }
+  PlayList->insertRow(currentRow+1);
+	for(int i=0; i< PlayList->rowCount(); ++i){
+		PlayList->setRowHeight(i, 20);
+	}
+  //PlayList->setRowHeight(currentRow + 1, 20);
+
+	// eye item
+	QTableWidgetItem * eye_item = new QTableWidgetItem;
+	eye_item->setFlags(Qt::ItemIsEnabled);
+	PlayList->setItem(currentRow + 1, 0, eye_item);
+	// style module name item
+	QTableWidgetItem * style_module_name_item = new QTableWidgetItem(fi.fileName());
+	style_module_name_item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
+  PlayList->setItem(currentRow + 1, 1, style_module_name_item);
+  PlayList->setItem(currentRow + 1, 3, new QTableWidgetItem(iFileName));
+	// refresh item
+	QTableWidgetItem * refresh_item = new QTableWidgetItem;
+	refresh_item->setFlags(Qt::ItemIsEnabled);
+	PlayList->setItem(currentRow + 1, 2, refresh_item);
+	
+	setModified(currentRow + 1, true);
+	QTableWidgetItem *checkItem = new QTableWidgetItem;
+  checkItem->setFlags(Qt::ItemIsUserCheckable);
+  if(iDisp)
+	  checkItem->setCheckState(Qt::Checked);
+  else
+		checkItem->setCheckState(Qt::Unchecked);
+  PlayList->setItem(currentRow + 1, 4, checkItem);
+  setChecked(currentRow + 1, iDisp);
+	PlayList->setCurrentCell(currentRow + 1, 1);
+	//PlayList->setRangeSelected(QTableWidgetSelectionRange( currentRow+1, 0, currentRow+1, 4), true);
+	QString text = (PlayList->item(currentRow + 1, 3))->text();
+	PlayList->takeVerticalHeaderItem(currentRow + 1);
+  _pInteractiveShaderWindow->setCurrentShaderRow(currentRow + 1);
+  _pInteractiveShaderWindow->DisplayShader(text);
+
+  // Load the shader in memory and add it to the 
+  // canvas list
+  g_pController->InsertStyleModule(currentRow + 1, iFileName);
+  g_pController->toggleLayer(currentRow + 1, iDisp);
+}
+
+void AppStyleWindow::AddList(const char* iFileName) {
+  ifstream ifs(iFileName);
+  if (!ifs.is_open()) {
+    cerr << "Error: Cannot load this file" << endl;
+    return;
+  }
+  QFileInfo fi(iFileName);
+  char tmp_buffer[256];
+  string s;
+  bool disp = true;
+  while (!ifs.eof()) {
+    ifs.getline(tmp_buffer, 255);
+    if (!tmp_buffer[0] || tmp_buffer[0] == '#')
+      continue;
+    if (tmp_buffer[0] == '0')
+      disp = false;
+    else
+      disp = true;
+    s = (const char*)fi.dir().path().toAscii().data();
+    s += Config::DIR_SEP;
+    s += tmp_buffer + 1;
+    ifstream test(s.c_str(), ios::binary);
+    if (!test.is_open()) {
+      cerr << "Error: Cannot load \"" << tmp_buffer + 1 << "\"" << endl;
+      continue;
+    }
+    Add(s.c_str(), disp);
+  }
+}
+
+void AppStyleWindow::SaveList() {
+  QString s = QFileDialog::getSaveFileName(
+						this,
+	  				   "Save file dialog"
+					   "Choose a file",
+						g_pController->getModulesDir(),
+					   "Style modules lists (*." + Config::STYLE_MODULES_LIST_EXTENSION + ")");
+
+  if (s.isEmpty())
+    return;
+  QFileInfo fi( s );
+  QString ext = fi.suffix();
+  if (ext != Config::STYLE_MODULES_LIST_EXTENSION)
+    s += "." + Config::STYLE_MODULES_LIST_EXTENSION;
+  ofstream ofs(s.toAscii().data(), ios::binary);
+  if (!ofs.is_open()) {
+    cerr << "Error: Cannot save this file" << endl;
+    return;
+  }
+  
+  QTableWidgetItem *checkItem;
+	for (unsigned i = 0 ; i < PlayList->rowCount(); i++) {
+    checkItem = PlayList->item(i, 4);
+		ofs << ((checkItem->checkState() ==  Qt::Checked) ? '1' : '0');
+    ofs << PlayList->item(i, 1)->text().toAscii().data() << endl;
+  }
+  g_pController->setModulesDir(fi.dir().path());
+  cout << "Style modules list saved" << endl;
+}
+
+void AppStyleWindow::Add()
+{
+  // Load Module
+  QString s = QFileDialog::getOpenFileName(this,
+						"Open file dialog"
+					   "Choose a file",
+						g_pController->getModulesDir(),
+					   "Style modules (*." + Config::STYLE_MODULE_EXTENSION + ")"
+					   ";;"
+					   "Style modules lists (*." + Config::STYLE_MODULES_LIST_EXTENSION + ")");
+
+  QFileInfo fi( s );
+  QString ext = fi.suffix();   // ext is taken after the last dot.
+
+  if (ext == Config::STYLE_MODULE_EXTENSION) {
+    g_pController->setModulesDir(fi.dir().path());
+    Add(s.toAscii().data());
+  }
+  else if (ext == Config::STYLE_MODULES_LIST_EXTENSION) {
+    g_pController->setModulesDir(fi.dir().path());
+    AddList(s.toAscii().data());
+  }
+}
+
+void AppStyleWindow::Remove()
+{
+  // Remove the selected item
+  g_pController->RemoveStyleModule(PlayList->currentRow());
+  PlayList->removeRow(PlayList->currentRow());
+  _pInteractiveShaderWindow->fileClose();
+}
+
+void AppStyleWindow::Clear()
+{
+  g_pController->Clear();
+	for (int i = PlayList->rowCount() - 1; i >= 0; i--)
+    PlayList->removeRow(i);
+  _pInteractiveShaderWindow->fileClose();
+}
+
+void AppStyleWindow::ExposeInteractiveShader()
+{
+  _pInteractiveShaderWindow->show();
+  //_pInteractiveShaderWindow->Load();
+}
+
+void AppStyleWindow::setModified(unsigned row, bool mod) {
+  if (mod) {
+		PlayList->item(row, 2)->setIcon(QIcon(*_mod1_image));
+    return;
+  }
+  Canvas* canvas = Canvas::getInstance();
+  StyleModule* sm = canvas->getCurrentStyleModule();
+  if (sm && sm->getAlwaysRefresh())
+    return;
+  PlayList->item(row, 2)->setIcon(QIcon(*_mod0_image));
+}
+
+void AppStyleWindow::setChecked(unsigned row, bool check) {
+  if (check)
+		PlayList->item(row, 0)->setIcon(QIcon(*_disp1_image));
+  else
+		PlayList->item(row, 0)->setIcon(QIcon(*_disp0_image));
+}
+
+void AppStyleWindow::Edit() {
+	if(PlayList->rowCount() == 0)
+    return;
+
+  int currentRow = PlayList->currentRow();
+
+  ExposeInteractiveShader();
+	QString text = (PlayList->item(currentRow, 3)->text());
+  _pInteractiveShaderWindow->setCurrentShaderRow(currentRow);
+  _pInteractiveShaderWindow->DisplayShader(text);
+}
+
+void AppStyleWindow::Display( int row, int col ) {
+  if(col != 1)
+    return;
+
+  Edit();
+}
+
+void AppStyleWindow::ToggleLayer(int row, int col)
+{
+  if(0 == PlayList->rowCount())
+    return;
+  
+  if(col != 0)
+    return;
+
+	QTableWidgetItem *checkItem = PlayList->item(row, 4);
+	if(checkItem->flags() != Qt::ItemIsUserCheckable)
+    return;
+
+	bool isChecked;
+	if(checkItem->checkState() == Qt::Checked){
+		checkItem->setCheckState(Qt::Unchecked);
+		isChecked = false;
+	}else{
+		checkItem->setCheckState(Qt::Checked);
+		isChecked = true;
+	}
+  g_pController->toggleLayer(row, isChecked);
+  setChecked(row, isChecked);
+}
+
+void AppStyleWindow::Up() {
+  int current = PlayList->currentRow();
+  if (current > 0) {
+    SwapShaders(current, current - 1);
+    PlayList->clearSelection();
+
+		PlayList->setRangeSelected(QTableWidgetSelectionRange( current-1, 0, current-1, 4), true);
+		PlayList->setCurrentCell(current-1, 1);
+    g_pController->updateCausalStyleModules(current - 1);
+		current = current-1;
+  }
+}
+
+void AppStyleWindow::Down() {
+  int current = PlayList->currentRow();
+  if (current < PlayList->rowCount() - 1) {
+    SwapShaders(current, current + 1);
+    PlayList->clearSelection();
+
+    PlayList->setRangeSelected(QTableWidgetSelectionRange( current+1, 0, current+1, 4), true);
+		PlayList->setCurrentCell(current+1, 1);
+
+    g_pController->updateCausalStyleModules(current);
+		current = current +1;
+  }
+}
+
+void AppStyleWindow::fileSave() {
+  int current = _pInteractiveShaderWindow->getCurrentShaderRow();
+	QString text = (PlayList->item(current, 3)->text());
+  g_pController->ReloadStyleModule(current, text.toAscii().data());
+	QTableWidgetItem *checkItem = PlayList->item(current, 4);
+	bool isChecked = (checkItem->checkState() == Qt::Checked) ? true : false;
+  g_pController->toggleLayer(current, isChecked);
+}
+
+void AppStyleWindow::resetModified(bool iMod)
+{
+  for(int i=0; i < PlayList->rowCount(); i++)
+  {
+    setModified(i,iMod);
+  }
+}
+
+void AppStyleWindow::SwapShaders(int i1, int i2) {
+  g_pController->SwapStyleModules(i1, i2);
+  //PlayList->swapRows(i1, i2);
+	QTableWidgetItem *first_row_items[5];
+	QTableWidgetItem *second_row_items[5];
+	int i;
+	for(i=0;i<5;++i){
+		first_row_items[i] = PlayList->takeItem(i1, i);
+		second_row_items[i] = PlayList->takeItem(i2, i);
+	}
+	for(i=0;i<5;++i){
+		PlayList->setItem(i1, i, second_row_items[i]);
+		PlayList->setItem(i2, i, first_row_items[i]);
+	}
+}
diff --git a/source/blender/freestyle/intern/app/AppStyleWindow.h b/source/blender/freestyle/intern/app/AppStyleWindow.h
new file mode 100755
index 00000000000..a9339abf9c8
--- /dev/null
+++ b/source/blender/freestyle/intern/app/AppStyleWindow.h
@@ -0,0 +1,93 @@
+//
+//  Filename         : AppStyleWindow.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class to define the style window
+//  Date of creation : 18/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ARTSTYLEWINDOW_H
+#define  ARTSTYLEWINDOW_H
+
+#include <QKeyEvent>
+#include <QWidget>
+#include <QPainter>
+#include <QColorGroup>
+#include "ui_dir/ui_stylewindow4.h"
+
+using namespace Ui;
+
+class AppInteractiveShaderWindow;
+class AppStyleWindow : public QDialog, public StyleWindow
+{
+  Q_OBJECT
+public:
+	AppStyleWindow(QWidget* parent = 0, const char* name = 0, Qt::WFlags fl = 0);
+  virtual ~AppStyleWindow();
+
+  void ExposeInteractiveShader();
+  /*! sets all layers to visible */
+  //void resetLayers();
+  
+  virtual int  currentRow() const { return PlayList->currentRow(); }
+  virtual void setModified(unsigned row, bool mod);
+  virtual void resetModified(bool iMod = false);
+  virtual void setChecked(unsigned row, bool check);
+
+public slots:
+    virtual void Add();
+    virtual void Add(const char* iFileName, bool iDisp = true);
+    virtual void SaveList();
+    virtual void Remove();
+    virtual void Clear();
+    virtual void Up();
+    virtual void Down();
+    virtual void Edit();
+    virtual void Close() { close(); }
+    virtual void Display( int row, int col);
+    virtual void ToggleLayer(int row, int col);
+    virtual void SwapShaders(int i1, int i2);
+    void fileSave();
+
+ protected:
+    
+    void keyPressEvent(QKeyEvent *e) {
+		if (e->key() == Qt::Key_Escape)
+	return;
+		QDialog::keyPressEvent(e);
+    }
+
+private:
+
+    void AddList(const char* iFileName);
+
+    AppInteractiveShaderWindow* _pInteractiveShaderWindow;
+
+    QPixmap* _mod0_image;
+    QPixmap* _mod1_image;
+    QPixmap* _disp0_image;
+    QPixmap* _disp1_image;
+};
+
+#endif // ARTSTYLEWINDOW_H
diff --git a/source/blender/freestyle/intern/app/ConfigIO.cpp b/source/blender/freestyle/intern/app/ConfigIO.cpp
new file mode 100755
index 00000000000..8165deb07fd
--- /dev/null
+++ b/source/blender/freestyle/intern/app/ConfigIO.cpp
@@ -0,0 +1,116 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include <qfileinfo.h>
+#include <qdir.h>
+#include "ConfigIO.h"
+
+ConfigIO::ConfigIO(QString filename, const QString& doc_type, bool automatic, const QString& sep)
+  : _default_file(filename), _automatic(automatic) {
+  _doc_type = doc_type;
+  _path_sep = sep;
+  if (_automatic)
+    loadFile();
+}
+
+ConfigIO::~ConfigIO() {
+  if (_automatic)
+    saveFile();
+}
+
+QString	ConfigIO::getDefaultFile() const {
+  return _default_file;
+}
+
+void	ConfigIO::setDefaultFile(const QString& filename) {
+  _default_file = filename;
+}
+
+bool	ConfigIO::getAuto() const {
+  return _automatic;
+}
+
+void	ConfigIO::setAuto(bool automatic) {
+  _automatic = automatic;
+}
+
+QString	ConfigIO::getPathSep() const {
+  return _path_sep;
+}
+
+void	ConfigIO::setPathSep(const QString& sep) {
+  _path_sep = sep;
+}
+
+int	ConfigIO::loadFile(const QString& _filename) {
+
+  const QString filename = _filename.isEmpty() ? _default_file : _filename;
+
+  // check wether filename is a valid file and is readable
+  QFileInfo fileinfo(filename);
+  if (!fileinfo.isFile() || !fileinfo.isReadable()) {
+    std::cerr << "Warning: unable to load configuration file \""
+	 << fileinfo.fileName().toAscii().data() << "\"" << std::endl;
+    return 1;
+  }
+
+  // read the DOM tree from file
+  QFile file(filename);
+  file.open(QIODevice::ReadOnly);
+  _tree.setContent(&file);
+  file.close();
+
+  return 0;
+}
+
+int	ConfigIO::saveFile(const QString& _filename) const {
+
+  QString str_tree = _tree.toString();
+  if (str_tree.isEmpty())
+    return 1;
+
+  const QString filename = _filename.isEmpty() ? _default_file : _filename;
+
+  // if the directory in which we want to generate a file
+  // does not exist yet, try to create it
+  QFileInfo fileinfo(filename);
+  if (!fileinfo.exists()) {
+    QDir dir;
+    dir.mkdir(fileinfo.dir().path());
+  }
+
+  // check wether filename is a valid file and is writable
+  QFile file(filename);
+  file.open(QIODevice::WriteOnly);
+  if (!file.isOpen()) {
+    std::cerr << "Warning: unable to save configuration file \""
+	 << fileinfo.fileName().toAscii().data() << "\"" << std::endl;
+    return 1;
+  }
+
+  // write the DOM tree to file
+  QTextStream out(&file);
+  out << str_tree;
+  file.close();
+
+  return 0;
+}
diff --git a/source/blender/freestyle/intern/app/ConfigIO.h b/source/blender/freestyle/intern/app/ConfigIO.h
new file mode 100755
index 00000000000..15f3cd07575
--- /dev/null
+++ b/source/blender/freestyle/intern/app/ConfigIO.h
@@ -0,0 +1,181 @@
+//
+//  Filename         : ConfigIO.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Configuration management
+//  Date of creation : 26/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CONFIGIO_H
+# define CONFIGIO_H
+
+# include <qstring.h>
+# include <qstringlist.h>
+# include <qtextstream.h>
+# include <qdom.h>
+# include "../system/FreestyleConfig.h"
+
+class ConfigIO
+{
+ public:
+
+  ConfigIO(QString filename = "",
+	   const QString& doc_type = "config_file",
+	   bool automatic = false,
+	   const QString& sep = "/");
+  ~ConfigIO();
+
+  QString	getDefaultFile() const;
+  void		setDefaultFile(const QString& filename);
+
+  bool		getAuto() const;
+  void		setAuto(bool automatic);
+
+  QString	getPathSep() const;
+  void		setPathSep(const QString& sep);
+
+  int		loadFile(const QString& filename = "");
+  int		saveFile(const QString& filename = "") const;
+
+  template <class T> int	getValue(const QString& path, T& res) const;
+  template <class T> int	setValue(const QString& path, const T& src);
+
+ private:
+
+  QString		_path_sep;
+  QString		_default_file;
+  bool			_automatic;
+
+  QDomDocument		_tree;
+  QString		_doc_type;
+};
+
+
+//
+// Implementation of templated methods
+//
+///////////////////////////////////////////////////
+
+namespace Internal {
+
+  template <class T>
+  struct	readValue {
+    void operator()(const QString &value, T &res) {
+        QTextStream((QString *)&value, QIODevice::ReadOnly)>> res;
+    }
+  };
+
+  template <>
+  struct	readValue<QString> {
+    void operator()(const QString& value, QString& res) {
+      res = value;
+    }
+  };
+
+  template <>
+  struct	readValue<bool> {
+    void operator()(const QString& value, bool& res) {
+      short res_tmp;
+      QTextStream((QString *)&value, QIODevice::ReadOnly) >> res_tmp;
+      res = res_tmp;
+    }
+  };
+
+} // end of namespace Internal
+
+
+template <class T>
+int	ConfigIO::getValue(const QString& path, T& res) const {
+
+  // Split path
+  QStringList strlist;
+  strlist = path.split(_path_sep);
+
+  unsigned size = strlist.size();
+  if (size-- < 2)
+    return 1;
+
+  // try to find the right element
+  QDomElement right_node;
+  QDomElement node = _tree.documentElement().firstChild().toElement();
+  for (unsigned i = 0;
+       !node.isNull() && i < size;
+       node = node.firstChild().toElement(), i++) {
+    while (!node.isNull() && node.tagName() != strlist[i])
+      node = node.nextSibling().toElement();
+    right_node = node;
+  }
+
+  // and the right attribute
+  if (right_node.hasAttribute(strlist[size])) {
+    QString value = right_node.attribute(strlist[size]);
+    Internal::readValue<T> rv;
+    rv(value, res);
+    return 0;
+  }
+
+  return 1;
+}
+
+
+template <class T>
+int	ConfigIO::setValue(const QString& path, const T& src) {
+
+  // Split path
+  QStringList strlist = path.split(_path_sep);
+
+  unsigned size = strlist.size();
+  if (size-- < 2)
+    return 1;
+
+  // verify that the tree isn't empty
+  // if so, create a root
+  QDomElement node = _tree.documentElement();
+  if (node.isNull()) {
+      node = _tree.createElement(_doc_type);
+      _tree.appendChild(node);
+  }
+  
+  // find the right element
+  QDomElement child = node.firstChild().toElement();
+  for (unsigned i = 0;
+       i < size;
+       node = child, child = child.firstChild().toElement(), i++) {
+    while (!child.isNull() && child.tagName() != strlist[i])
+      child = child.nextSibling().toElement();
+    if (child.isNull()) {
+      child = _tree.createElement(strlist[i]);
+      node.appendChild(child);
+    }
+  }
+
+  // and set the attribute
+  QString value;
+  QTextStream(&value, QIODevice::WriteOnly) << src;
+  node.setAttribute(strlist[size], value);
+
+  return 0;
+}
+
+#endif // CONFIGIO_H
diff --git a/source/blender/freestyle/intern/app/Controller.cpp b/source/blender/freestyle/intern/app/Controller.cpp
new file mode 100755
index 00000000000..fc4912af5e6
--- /dev/null
+++ b/source/blender/freestyle/intern/app/Controller.cpp
@@ -0,0 +1,1498 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Must be included before any QT header, because of moc
+#include "../system/PythonInterpreter.h"
+
+#include <fstream>
+#include <float.h>
+#include <qfileinfo.h>
+#include <qprocess.h>
+#include <qstring.h>
+
+#include "AppGLWidget.h"
+#include "AppMainWindow.h"
+#include "AppProgressBar.h"
+#include "AppStyleWindow.h"
+#include "AppOptionsWindow.h"
+#include "AppAboutWindow.h"
+#include "AppCanvas.h"
+#include "AppConfig.h"
+#include "AppDensityCurvesWindow.h"
+
+#include "../system/StringUtils.h"
+#include "../scene_graph/MaxFileLoader.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/NodeTransform.h"
+#include "../scene_graph/NodeDrawingStyle.h"
+#include "../winged_edge/WingedEdgeBuilder.h"
+#include "../winged_edge/WEdge.h"
+#include "../scene_graph/VertexRep.h"
+#include "../winged_edge/WXEdgeBuilder.h"
+#include "../scene_graph/ScenePrettyPrinter.h"
+#include "../winged_edge/WFillGrid.h"
+
+#include "../view_map/ViewMapTesselator.h"
+#include "../stroke/StrokeTesselator.h"
+#include "../view_map/ViewMapIO.h"
+#include "Controller.h"
+#include "../view_map/ViewMap.h"
+#include "../winged_edge/Curvature.h"
+#include "QGLBasicWidget.h"
+#include <qimage.h>
+#include "../image/Image.h"
+#include "../view_map/SteerableViewMap.h"
+#include "../stroke/PSStrokeRenderer.h"
+#include "../stroke/TextStrokeRenderer.h"
+#include "../stroke/StyleModule.h"
+
+#ifndef WIN32
+//# include "GLXOffscreenBuffer.h"
+//# include "GLXOffscreenBuffer.h"
+#endif
+
+Controller::Controller()
+{
+  const QString sep(Config::DIR_SEP.c_str());
+  const QString filename = Config::Path::getInstance()->getHomeDir() + sep +
+    Config::OPTIONS_DIR + sep + Config::OPTIONS_CURRENT_DIRS_FILE;
+  _current_dirs = new ConfigIO(filename, Config::APPLICATION_NAME + "CurrentDirs", true);
+
+  _RootNode = new NodeGroup;
+  _RootNode->addRef();
+  
+  _SilhouetteNode = NULL;
+  //_ProjectedSilhouette = NULL;
+  //_VisibleProjectedSilhouette = NULL;
+  
+  _DebugNode = new NodeGroup;
+  _DebugNode->addRef();
+
+  _winged_edge = NULL;
+  
+  _pMainWindow = NULL;
+  _pView = NULL;
+
+  _edgeTesselationNature = (Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE);
+
+  _ProgressBar = new AppProgressBar;
+  _SceneNumFaces = 0;
+  _minEdgeSize = DBL_MAX;
+  _bboxDiag = 0;
+  
+  _ViewMap = 0;
+
+  _Canvas = 0;
+
+  _VisibilityAlgo = ViewMapBuilder::ray_casting;
+  //_VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+
+  _Canvas = new AppCanvas;
+
+  _inter = new PythonInterpreter;
+  _EnableQI = true;
+  _ComputeRidges = true;
+  _ComputeSteerableViewMap = false;
+  _ComputeSuggestive = true;
+  _sphereRadius = 1.0;
+}
+
+Controller::~Controller()
+{
+  if(NULL != _RootNode)
+    {
+      int ref = _RootNode->destroy();
+      if(0 == ref)
+	delete _RootNode;
+    }
+  
+  if(NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	delete _SilhouetteNode;
+    }
+  
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	delete _DebugNode;
+    }
+
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	delete _VisibleProjectedSilhouette;
+  //    }
+  
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	delete _ProjectedSilhouette;
+  //    }
+
+  if(NULL != _ProgressBar)
+    {
+      delete _ProgressBar;
+      _ProgressBar = NULL;
+    }
+
+  if(_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
+
+  if(0 != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  if(0 != _Canvas)
+    {
+      delete _Canvas;
+      _Canvas = 0;
+    }
+
+  if (_inter) {
+    delete _inter;
+    _inter = NULL;
+  }
+
+  //  if(_pDensityCurvesWindow){
+  //    delete _pDensityCurvesWindow;
+  //    _pDensityCurvesWindow = 0;
+  //  }
+  delete _current_dirs;
+}
+
+void Controller::SetView(AppGLWidget *iView)
+{
+  if(NULL == iView)
+    return;
+  
+  _pView = iView;
+  //_pView2D->setGeometry(_pView->rect());
+  _Canvas->setViewer(_pView);
+}
+
+void Controller::SetMainWindow(AppMainWindow *iMainWindow)
+{
+  _pMainWindow = iMainWindow;
+  _ProgressBar->setQTProgressBar(_pMainWindow->qtProgressDialog());
+	_pStyleWindow = new AppStyleWindow(_pMainWindow, "StyleWindow");
+  _pOptionsWindow = new AppOptionsWindow(_pMainWindow, "MainWindow");
+  _pDensityCurvesWindow = new AppDensityCurvesWindow(_pMainWindow, "MainWindow");
+}
+
+int Controller::Load3DSFile(const char *iFileName)
+{
+  if (_pView)
+    _pView->setUpdateMode(false);
+
+  //_pMainWindow->InitProgressBar("Loading 3DS Model", 4);
+  _ProgressBar->reset();
+  _ProgressBar->setLabelText("Loading 3DS Model");
+  _ProgressBar->setTotalSteps(3);
+  _ProgressBar->setProgress(0);
+
+  //_pMainWindow->setProgressLabel("Reading File");
+  //_pMainWindow->setProgressLabel("Cleaning mesh");
+  
+  _pMainWindow->DisplayMessage("Reading File");
+  _pMainWindow->DisplayMessage("Cleaning Mesh");
+  
+  MaxFileLoader loader3DS(iFileName);
+  //_RootNode->AddChild(BuildSceneTest());
+  
+  _Chrono.start();
+  
+  NodeGroup *maxScene = loader3DS.Load();
+
+  if (maxScene == NULL) {
+    _ProgressBar->setProgress(3);
+    return 1;
+  }
+
+  printf("Mesh cleaning    : %lf\n", _Chrono.stop());
+  _SceneNumFaces += loader3DS.numFacesRead();
+
+  if(loader3DS.minEdgeSize() < _minEdgeSize)
+    {
+      _minEdgeSize = loader3DS.minEdgeSize();
+      _EPSILON = _minEdgeSize*1e-6;
+      if(_EPSILON < DBL_MIN)
+	_EPSILON = 0.0;
+    }
+
+  cout << "Epsilon computed : " << _EPSILON << endl;
+
+  _ProgressBar->setProgress(1);
+
+  // DEBUG
+//   ScenePrettyPrinter spp;
+//   maxScene->accept(spp);
+
+  _RootNode->AddChild(maxScene);
+  _RootNode->UpdateBBox(); // FIXME: Correct that by making a Renderer to compute the bbox
+
+  _pView->setModel(_RootNode);
+  _pView->FitBBox();
+  
+  _pMainWindow->DisplayMessage("Building Winged Edge structure");
+  _Chrono.start();
+
+  
+  WXEdgeBuilder wx_builder;
+  maxScene->accept(wx_builder);
+  _winged_edge = wx_builder.getWingedEdge();
+
+  printf("WEdge building   : %lf\n", _Chrono.stop());
+
+  _ProgressBar->setProgress(2);
+
+  _pMainWindow->DisplayMessage("Building Grid");
+ _Chrono.start();
+
+  _Grid.clear();
+  Vec3r size;
+  for(unsigned int i=0; i<3; i++)
+    {
+      size[i] = fabs(_RootNode->bbox().getMax()[i] - _RootNode->bbox().getMin()[i]);
+      size[i] += size[i]/10.0; // let make the grid 1/10 bigger to avoid numerical errors while computing triangles/cells intersections
+      if(size[i]==0){
+          cout << "Warning: the bbox size is 0 in dimension "<<i<<endl;
+      }
+    }
+  _Grid.configure(Vec3r(_RootNode->bbox().getMin() - size / 20.0), size,
+		  _SceneNumFaces);
+
+  // Fill in the grid:
+  WFillGrid fillGridRenderer(&_Grid, _winged_edge);
+  fillGridRenderer.fillGrid();
+
+  printf("Grid building    : %lf\n", _Chrono.stop());
+  
+  // DEBUG
+//   _Grid.displayDebug();
+
+  _ProgressBar->setProgress(3);
+   
+  _pView->setDebug(_DebugNode);
+
+  //delete stuff
+  //  if(0 != ws_builder)
+  //    {
+  //      delete ws_builder;
+  //      ws_builder = 0;
+  //    }
+  _pView->updateGL();
+  QFileInfo qfi(iFileName);
+  string basename((const char*)qfi.fileName().toAscii().data());
+  _ListOfModels.push_back(basename);
+
+  cout << "Triangles nb     : " << _SceneNumFaces << endl;
+  _bboxDiag = (_RootNode->bbox().getMax()-_RootNode->bbox().getMin()).norm();
+  cout << "Bounding Box     : " << _bboxDiag << endl;
+  return 0;
+}
+
+void Controller::CloseFile()
+{
+  WShape::SetCurrentId(0);
+  _pView->DetachModel();
+  _ListOfModels.clear();
+  if(NULL != _RootNode)
+    {
+      int ref = _RootNode->destroy();
+      if(0 == ref)
+	_RootNode->addRef();
+    
+      _RootNode->clearBBox();
+    }
+  
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	{
+	  delete _SilhouetteNode;
+	  _SilhouetteNode = NULL;
+	}
+    }
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _ProjectedSilhouette;
+  //	  _ProjectedSilhouette = NULL;
+  //	}
+  //    }
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _VisibleProjectedSilhouette;
+  //	  _VisibleProjectedSilhouette = NULL;
+  //	}
+  //  }
+  
+  _pView->DetachDebug();
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	_DebugNode->addRef();
+    }
+  
+  if(_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
+
+  // We deallocate the memory:
+  if(NULL != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  // clears the canvas
+  _Canvas->Erase();
+
+  // clears the grid
+  _Grid.clear();
+  _SceneNumFaces = 0;
+  _minEdgeSize = DBL_MAX;
+  //  _pView2D->DetachScene();
+  //  if(NULL != _SRoot)
+  //  {
+  //    int ref = _SRoot->destroy();
+  //    if(0 == ref)
+  //    {
+  //      //_SRoot->addRef();
+  //      delete _SRoot;
+  //      _SRoot = NULL;
+  //    }
+  //  }
+}
+
+//  static const streamsize buffer_size = 512 * 1024;
+
+void Controller::SaveViewMapFile(const char *oFileName)
+{
+  if (!_ViewMap)
+    return;
+
+  ofstream ofs(oFileName, ios::binary);
+  if (!ofs.is_open()) {
+    _pMainWindow->DisplayMessage("Error: Cannot save this file");
+    cerr << "Error: Cannot save this file" << endl;
+    return;
+  }
+//    char buffer[buffer_size];
+//  #if defined(__GNUC__) && (__GNUC__ < 3)
+//    ofs.rdbuf()->setbuf(buffer, buffer_size);
+//  # else
+//    ofs.rdbuf()->pubsetbuf(buffer, buffer_size);
+//  #endif
+  _Chrono.start();
+
+  ofs << Config::VIEWMAP_MAGIC.toAscii().data() << endl << Config::VIEWMAP_VERSION.toAscii().data() << endl;
+
+  // Write the models filenames
+  ofs << _ListOfModels.size() << endl;
+  for (vector<string>::const_iterator i = _ListOfModels.begin(); i != _ListOfModels.end(); i++)
+    ofs << *i << "\n";
+
+  // Save the camera position
+  float position[3];
+  float orientation[4];
+  _pView->getCameraState(position, orientation);
+  ofs.write((char*)position, 3 * sizeof(*position));
+  ofs.write((char*)orientation, 4 * sizeof(*orientation));
+
+  // Write ViewMap
+  if (ViewMapIO::save(ofs, _ViewMap, _ProgressBar)) {
+    _Chrono.stop();
+    cerr << "Error: Cannot save this file" << endl;
+    return;
+  }
+
+  real d = _Chrono.stop();
+  cout << "ViewMap saving   : " << d << endl;
+}
+
+void Controller::LoadViewMapFile(const char *iFileName, bool only_camera)
+{
+  ifstream ifs(iFileName, ios::binary);
+  if (!ifs.is_open()) {
+    _pMainWindow->DisplayMessage("Error: Cannot load this file");
+    cerr << "Error: Cannot load this file" << endl;
+    return;
+  }
+//    char buffer[buffer_size];
+//  #if defined(__GNUC__) && (__GNUC__ < 3)
+//    ifs.rdbuf()->setbuf(buffer, buffer_size);
+//  # else
+//    ifs.rdbuf()->pubsetbuf(buffer, buffer_size);
+//  #endif
+
+  // Test File Magic and version
+  char tmp_buffer[256];
+  QString test;
+  
+  ifs.getline(tmp_buffer, 255);
+  test = tmp_buffer;
+  if (test != Config::VIEWMAP_MAGIC) {
+    _pMainWindow->DisplayMessage(
+		(QString("Error: This is not a valid .") + Config::VIEWMAP_EXTENSION + QString(" file")).toAscii().data());
+    cerr << "Error: This is not a valid ." << Config::VIEWMAP_EXTENSION.toAscii().data() << " file" << endl;
+    return;
+  }
+  ifs.getline(tmp_buffer, 255);
+  test = tmp_buffer;
+  if (test != Config::VIEWMAP_VERSION && !only_camera) {
+    _pMainWindow->DisplayMessage(
+		(QString("Error: This version of the .") + Config::VIEWMAP_EXTENSION + QString(" file format is no longer supported")).toAscii().data());
+    cerr << "Error: This version of the ." << Config::VIEWMAP_EXTENSION.toAscii().data() << " file format is no longer supported" << endl;
+    return;
+  }
+
+  // Read the models filenames and open them (if not already done)
+  string tmp;
+  vector<string> tmp_vec;
+  unsigned models_nb, i;
+
+  ifs.getline(tmp_buffer, 255);
+  models_nb = atoi(tmp_buffer);
+  for (i = 0; i < models_nb; i++) {
+    ifs.getline(tmp_buffer, 255);
+    tmp = tmp_buffer;
+    tmp_vec.push_back(tmp);
+  }
+  if (_ListOfModels != tmp_vec && !only_camera) {
+    CloseFile();
+    vector<string> pathnames;
+    int err = 0;
+    for (vector<string>::const_iterator i = tmp_vec.begin(); i != tmp_vec.end(); i++)
+      {
+	pathnames.clear();
+	StringUtils::getPathName(ViewMapIO::Options::getModelsPath(), *i, pathnames);
+	for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++)
+	  if (!(err = Load3DSFile(j->c_str())))
+	    break;
+	if (err) {
+	  _pMainWindow->DisplayMessage("Error: cannot find the right model(s)");
+	  cerr << "Error: cannot find model \"" << *i << "\" - check the path in the Options" << endl;
+	  return;
+	}
+      }
+  }
+
+  // Set the camera position
+  float position[3];
+  float orientation[4];
+  ifs.read((char*)position, 3 * sizeof(*position));
+  ifs.read((char*)orientation, 4 * sizeof(*orientation));
+  _pView->setCameraState(position, orientation);
+  _pView->saveCameraState();
+
+  if (only_camera) {
+    _pMainWindow->DisplayMessage("Camera parameters loaded");
+    return;
+  }
+
+  // Reset ViewMap
+  if(NULL != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	delete _SilhouetteNode;
+    }
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	delete _ProjectedSilhouette;
+  //    }
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _VisibleProjectedSilhouette;
+  //	  _VisibleProjectedSilhouette = 0;
+  //	}
+   // }
+  _ViewMap = new ViewMap();
+
+  // Read ViewMap
+  _Chrono.start();
+  if (ViewMapIO::load(ifs, _ViewMap, _ProgressBar)) {
+    _Chrono.stop();
+    _pMainWindow->DisplayMessage(
+		(QString("Error: This is not a valid .") + Config::VIEWMAP_EXTENSION + QString(" file")).toAscii().data());
+    cerr << "Error: This is not a valid ." << Config::VIEWMAP_EXTENSION.toAscii().data() << " file" << endl;
+    return;
+  }
+
+  // Update display
+  _pMainWindow->DisplayMessage("Updating display");
+  ViewMapTesselator3D sTesselator3d;
+  //ViewMapTesselator2D sTesselator2d;
+  //sTesselator2d.setNature(_edgeTesselationNature);
+  sTesselator3d.setNature(_edgeTesselationNature);
+  
+  // Tesselate the 3D edges:
+  _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
+  _SilhouetteNode->addRef();
+  
+  // Tesselate 2D edges
+  //  _ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
+  //  _ProjectedSilhouette->addRef();
+  //  
+  _pView->AddSilhouette(_SilhouetteNode);
+  //_pView->Add2DSilhouette(_ProjectedSilhouette);
+
+  // Update options window
+  _pOptionsWindow->updateViewMapFormat();
+
+  real d = _Chrono.stop();
+  cout << "ViewMap loading  : " << d << endl;
+
+  // Compute the Directional ViewMap:
+  if(_ComputeSteerableViewMap){
+    ComputeSteerableViewMap();
+  }
+
+  // Reset Style modules modification flags
+  resetModified(true);
+}
+
+void Controller::ComputeViewMap()
+{
+
+  if (!_ListOfModels.size())
+    return;
+  
+  if(NULL != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  _pView->DetachDebug();
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	_DebugNode->addRef();
+    }
+  
+
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	delete _SilhouetteNode;
+    }
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	delete _ProjectedSilhouette;
+  //    }
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _VisibleProjectedSilhouette;
+  //	  _VisibleProjectedSilhouette = 0;
+  //	}
+  //  }
+  
+  // retrieve the 3D viewpoint and transformations information
+  //----------------------------------------------------------
+  // Save the viewpoint context at the view level in order 
+  // to be able to restore it later:
+  _pView->saveCameraState();
+
+  // Restore the context of view:
+  // we need to perform all these operations while the 
+  // 3D context is on.
+  _pView->set3DContext();
+  float src[3] = { 0, 0, 0 };
+  float vp_tmp[3];
+  _pView->camera()->getWorldCoordinatesOf(src, vp_tmp);
+  Vec3r vp(vp_tmp[0], vp_tmp[1], vp_tmp[2]);
+
+  real mv[4][4];
+  _pView->RetriveModelViewMatrix((real *)mv);
+  // retrieve the projection matrix:
+  real proj[4][4];
+  _pView->RetrieveProjectionMatrix((real *)proj);
+  int viewport[4];
+  _pView->RetrieveViewport(viewport);  
+  real focalLength = _pView->GetFocalLength();
+
+  // Flag the WXEdge structure for silhouette edge detection:
+  //----------------------------------------------------------
+
+  _Chrono.start();
+  if (_SceneNumFaces > 2000)
+    edgeDetector.setProgressBar(_ProgressBar);
+ 
+  edgeDetector.setViewpoint(Vec3r(vp));
+  edgeDetector.enableRidgesAndValleysFlag(_ComputeRidges);
+  edgeDetector.enableSuggestiveContours(_ComputeSuggestive);
+  edgeDetector.setSphereRadius(_sphereRadius);
+  edgeDetector.setSuggestiveContourKrDerivativeEpsilon(_suggestiveContourKrDerivativeEpsilon);
+  edgeDetector.processShapes(*_winged_edge);
+
+  real duration = _Chrono.stop();
+  printf("Feature lines    : %lf\n", duration);
+
+  // FIXME GLDEBUG
+  //====================================================================
+  //  NodeShape * silhouetteDebugShape = new NodeShape;
+  //  _DebugNode->AddChild(silhouetteDebugShape);
+  //  vector<WShape*>& wshapes = _winged_edge->getWShapes();
+  //  vector<WShape*>::iterator ws, wsend;
+  //  for(ws=wshapes.begin(), wsend=wshapes.end();
+  //  ws!=wsend;
+  //  ++ws){
+    // smooth
+//        vector<WVertex*>& wvertices = (*ws)->GetVertexList();
+//        unsigned modulo(1), currentIndex(0);
+//        for(vector<WVertex*>::iterator wv=wvertices.begin(), wvend=wvertices.end();
+//        wv!=wvend;
+//        ++wv){
+//          if(currentIndex%modulo != 0){
+//            ++currentIndex;
+//            continue;
+//          }else
+//            ++currentIndex;
+         
+//          WVertex::face_iterator fit=(*wv)->faces_begin();
+//          WVertex::face_iterator fitend=(*wv)->faces_end();
+//          for(; fit!=fitend; ++fit){
+//            WXFace *wxf = dynamic_cast<WXFace*>(*fit);
+//            unsigned vindex = wxf->GetIndex((*wv));
+//            vector<WXFaceLayer*> flayers;
+//            wxf->retrieveSmoothLayers(Nature::RIDGE, flayers);
+//            for(vector<WXFaceLayer*>::iterator fl=flayers.begin(), flend=flayers.end();
+//            fl!=flend;
+//            ++fl){
+//              Vec3r c[3];
+//              unsigned index = 0;
+//              for(unsigned i=0; i<3; ++i){
+// 	       //               real d = (*fl)->dotP(i);
+//                real d  = ((WXVertex*)(wxf->GetVertex(i)))->curvatures()->Kr;
+//                if(d < 0){
+//                  index = 1;
+//                  d = -d;
+//                }
+//                else
+//                  index = 0;
+//                c[i][index] = d;
+//              }  
+//            TriangleRep * frep = new TriangleRep( wxf->GetVertex(0)->GetVertex(),
+//              c[0],
+//              wxf->GetVertex(1)->GetVertex(),
+//              c[1],
+//              wxf->GetVertex(2)->GetVertex(),
+//              c[2]);
+//            silhouetteDebugShape->AddRep(frep);
+    //
+    //        //
+    //        Vec3r e2 = ((Face_Curvature_Info*)(*fl)->userdata)->vec_curvature_info[vindex]->e2;
+    //        Vec3r e1 = ((Face_Curvature_Info*)(*fl)->userdata)->vec_curvature_info[vindex]->e1;
+    //        OrientedLineRep * olrep1 = new OrientedLineRep((*wv)->GetVertex(), (*wv)->GetVertex()+e1);
+    //        OrientedLineRep * olrep2 = new OrientedLineRep((*wv)->GetVertex(), (*wv)->GetVertex()+e2);
+    //        silhouetteDebugShape->AddRep(olrep1);
+    //        silhouetteDebugShape->AddRep(olrep2);
+    //        WOEdge * oppositeEdge;
+    //        if(!(wxf->getOppositeEdge(*wv, oppositeEdge)))
+    //          continue;
+    //        Vec3r v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
+    //        OrientedLineRep * opplrep = new OrientedLineRep(oppositeEdge->GetaVertex()->GetVertex(), oppositeEdge->GetaVertex()->GetVertex()+v1v2);
+    //        silhouetteDebugShape->AddRep(opplrep);
+    //        GeomUtils::intersection_test res;
+    //        real t;
+    //        res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2,
+    //          e2, -((*wv)->GetVertex()*e2),
+    //          t,1.e-06);
+    //        if((res == GeomUtils::DO_INTERSECT) && (t>=0.0) && (t<=1.0)){
+    //          Vec3r inter(oppositeEdge->GetaVertex()->GetVertex() + t*v1v2);
+    //          VertexRep * irep = new VertexRep(inter.x(), inter.y(), inter.z());
+    //          irep->setPointSize(5.0);
+    //          silhouetteDebugShape->AddRep(irep);
+    //        }     
+// 	 }  
+//        }
+//        //break;
+//   }
+
+  //  vector<WFace*>& wfaces = (*ws)->GetFaceList();
+  //    for(vector<WFace*>::iterator wf=wfaces.begin(), wfend=wfaces.end();
+  //    wf!=wfend;
+  //    ++wf){
+  //      WXFace *wxf = dynamic_cast<WXFace*>(*wf);
+  //      vector<WXSmoothEdge*> smoothEdges;
+  //      wxf->retrieveSmoothEdges(Nature::RIDGE, smoothEdges);
+  //      for(vector<WXSmoothEdge*>::iterator se=smoothEdges.begin(), send=smoothEdges.end();
+  //      se!=send;
+  //      ++se){
+  //        real ta = (*se)->ta();
+  //        Vec3r A1((*se)->woea()->GetaVertex()->GetVertex());
+  //        Vec3r A2((*se)->woea()->GetbVertex()->GetVertex());
+  //        Vec3r A(A1+ta*(A2-A1));
+  //        
+  //        real tb = (*se)->tb();
+  //        Vec3r B1((*se)->woeb()->GetaVertex()->GetVertex());
+  //        Vec3r B2((*se)->woeb()->GetbVertex()->GetVertex());
+//        Vec3r B(B1+tb*(B2-B1));
+//        OrientedLineRep * line = new OrientedLineRep(A,B);
+//        silhouetteDebugShape->AddRep(line);
+//      }
+//      Material redmat;
+//      redmat.setDiffuse(1,0,0,1);
+//      Material greenmat;
+//      greenmat.setDiffuse(0,1,0,1);
+//      real vecSize = _bboxDiag/70.0;
+//      vector<WXFaceLayer*> flayers;
+//      wxf->retrieveSmoothLayers(Nature::RIDGE, flayers);
+//      for(vector<WXFaceLayer*>::iterator fl=flayers.begin(), flend=flayers.end();
+//      fl!=flend;
+//      ++fl){
+        //        Vec3r c[3];
+        //        unsigned nNegative = 0;
+        //        unsigned index = 0;
+        //        for(unsigned i=0; i<3; ++i){
+        //          //real d = (*fl)->dotP(i);
+        //          real d  = ((Face_Curvature_Info*)(*fl)->userdata)->vec_curvature_info[i]->K1/50.0;
+        //          //cout << d << endl;
+        //          if(d < 0){
+        //            nNegative++;
+        //            index = 1;
+        //            d = -d;
+        //          }
+        //          else
+        //            index = 0;
+        //          c[i][index] = d;
+        //        }
+        //        TriangleRep * frep = new TriangleRep( wxf->GetVertex(0)->GetVertex(),
+        //          c[0],
+        //          wxf->GetVertex(1)->GetVertex(),
+        //          c[1],
+        //          wxf->GetVertex(2)->GetVertex(),
+        //          c[2]);
+        //        //if((nNegative != 0) && (nNegative != 3))
+        //          silhouetteDebugShape->AddRep(frep);
+
+        // 3D CURVATURES
+        //==============
+        //        Face_Curvature_Info * fci = (Face_Curvature_Info*)(*fl)->userdata;
+        //        unsigned nvertices = wxf->numberOfVertices();
+        //        for(i=0; i<nvertices; ++i){
+        //          Curvature_info * ci = fci->vec_curvature_info[i];
+        //          Vec3r v(wxf->GetVertex(i)->GetVertex());
+        //          //          VertexRep *vrep = new VertexRep(v[0], v[1], v[2]);
+        //          //          vrep->setMaterial(redmat);
+        //          //          vrep->setPointSize(5.0);
+        //          //          silhouetteDebugShape->AddRep(vrep);
+        //          //          LineRep * maxc = new LineRep(v-vecSize*ci->e1/2.0, v+vecSize*ci->e1/2.0);
+        //          //          LineRep * maxc = new LineRep(v, v+vecSize*ci->e1);
+        //          //          maxc->setMaterial(redmat);
+        //          //          maxc->setWidth(2.0);
+        //          //          silhouetteDebugShape->AddRep(maxc);
+        //          LineRep * minc = new LineRep(v, v+vecSize*ci->e2);
+        //          minc->setMaterial(greenmat);
+        //          minc->setWidth(2.0);
+        //          silhouetteDebugShape->AddRep(minc);
+        //        }
+//      }
+//    }
+//  }
+ 
+  //  
+  //    // Sharp
+  //    vector<WEdge*>& wedges = (*ws)->GetEdgeList();
+  //    for(vector<WEdge*>::iterator we=wedges.begin(), weend=wedges.end();
+  //    we!=weend;
+  //    ++we){
+  //      WXEdge * wxe = dynamic_cast<WXEdge*>(*we);
+  //      if((wxe)->nature() != Nature::NO_FEATURE){
+  //        OrientedLineRep * line = new OrientedLineRep( wxe->GetaVertex()->GetVertex(),
+  //                                                      wxe->GetbVertex()->GetVertex());
+  //        silhouetteDebugShape->AddRep(line);
+  //      }
+  //    }
+  //  }
+  //  WVertex *wvertex = _winged_edge->getWShapes()[0]->GetVertexList()[0];
+  //  Vec3r v(wvertex->GetVertex());
+  //  VertexRep * vrep = new VertexRep(v[0],v[1], v[2]);
+  //  silhouetteDebugShape->AddRep(vrep );
+  //  WVertex::face_iterator fit = wvertex->faces_begin();
+  //  WVertex::face_iterator fitend = wvertex->faces_end();
+  //  while(fit!=fitend){
+  //    vector<WVertex*> fvertices;
+  //    (*fit)->RetrieveVertexList(fvertices);
+  //    Vec3r v[3];
+  //    unsigned i=0;
+  //    for(vector<WVertex*>::iterator fv=fvertices.begin(), fvend=fvertices.end();
+  //    fv!=fvend;
+  //    ++fv, ++i){
+  //      v[i] = (*fv)->GetVertex();
+  //    }
+  //    TriangleRep * triangle = new TriangleRep(v[0], v[1], v[2]);
+  //    silhouetteDebugShape->AddRep(triangle);
+  //    ++fit;
+  //  }
+  //====================================================================
+  // END GLDEBUG
+
+  // Builds the view map structure from the flagged WSEdge structure:
+  //----------------------------------------------------------
+  ViewMapBuilder vmBuilder;
+  vmBuilder.setProgressBar(_ProgressBar);
+  vmBuilder.setEnableQI(_EnableQI);
+  vmBuilder.setViewpoint(Vec3r(vp));
+  
+  vmBuilder.setTransform(mv, proj, viewport, focalLength, _pView->GetAspect(), _pView->GetFovyRadian());
+  vmBuilder.setFrustum(_pView->znear(), _pView->zfar());
+  
+  vmBuilder.setGrid(&_Grid);
+  
+  // Builds a tesselated form of the silhouette for display purpose:
+  //---------------------------------------------------------------
+  ViewMapTesselator3D sTesselator3d;
+  //ViewMapTesselator2D sTesselator2d;
+  //sTesselator2d.setNature(_edgeTesselationNature);
+  sTesselator3d.setNature(_edgeTesselationNature);
+    
+  _Chrono.start();
+  // Build View Map
+  _ViewMap = vmBuilder.BuildViewMap(*_winged_edge, _VisibilityAlgo, _EPSILON);
+  _ViewMap->setScene3dBBox(_RootNode->bbox());
+  
+  //Tesselate the 3D edges:
+  _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
+  _SilhouetteNode->addRef();
+  
+  // Tesselate 2D edges
+  //  _ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
+  //  _ProjectedSilhouette->addRef();
+  
+  duration = _Chrono.stop();
+  printf("ViewMap building : %lf\n", duration);
+
+  // FIXME DEBUG
+  //    vector<ViewVertex*>& vvertices = _ViewMap->ViewVertices();
+  //    for(vector<ViewVertex*>::iterator vv=vvertices.begin(), vvend=vvertices.end();
+  //    vv!=vvend;
+  //    ++vv){
+  //      TVertex * tvertex = (*vv)->castToTVertex();
+  //      if(!tvertex)
+  //        continue;
+  //      cout << "TVertex : " << tvertex->getId() << endl;
+  //      if (!(tvertex->frontEdgeA().first))
+  //        cout << "null FrontEdgeA" << endl;
+  //      if (!(tvertex->frontEdgeB().first))
+  //        cout << "null FrontEdgeB" << endl;
+  //      if (!(tvertex->backEdgeA().first))
+  //        cout << "null BackEdgeA" << endl;
+  //      if (!(tvertex->backEdgeB().first))
+  //        cout << "null backEdgeB" << endl;
+  //    }
+  //    cout << "-----------" << endl;
+  //    vector<SVertex*>& svertices = _ViewMap->SVertices();
+  //    unsigned i = 0;
+  //    for(vector<SVertex*>::iterator sv = svertices.begin(), svend = svertices.end();
+  //        sv != svend && i < 10;
+  //        ++sv, ++i) {
+  //      cout << "SVertex - Id : " << (*sv)->getId() << endl;
+  //      cout << "SVertex - P3D : " << (*sv)->point3D() << endl;
+  //      cout << "SVertex - P2D : " << (*sv)->point2D() << endl;
+  //      set<Vec3r>::const_iterator i;
+  //      unsigned tmp;
+  //      for (i = (*sv)->normals().begin(), tmp = 0;
+  // 	  i != (*sv)->normals().end();
+  // 	  i++, tmp++);
+  //      cout << "SVertex - Normals : " << tmp << endl;
+  //      cout << "SVertex - FEdges : " << (*sv)->fedges().size() << endl;
+  //    }
+  //    cout << "-----------" << endl;
+  //    vector<FEdge*>& fedges = _ViewMap->FEdges();
+  //    for(vector<FEdge*>::iterator fe = fedges.begin(), feend = fedges.end();
+  //        fe != feend && i < 10;
+  //        ++fe, ++i) {
+  //      cout << "FEdge - Id: " << (*fe)->getId() << endl;
+  //      cout << "FEdge - Occl: " << (*fe)->getOccludeeIntersection() << endl;
+  //    }
+  //    cout << "-----------" << endl;
+  // END DEBUG
+
+  // FIXME GLDEBUG
+  //====================================================================
+  // CUSPS
+  //=======
+  //  vector<ViewEdge*>& vedges = _ViewMap->ViewEdges();
+  //  //typedef ViewEdgeInternal::fedge_iterator_base<Nonconst_traits<FEdge*> > fedge_iterator;
+  //  //fedge_iterator fit = vedges[0]->fedge_iterator_begin();
+  //  for(vector<ViewEdge*>::iterator ve=vedges.begin(), veend=vedges.end();
+  //  ve!=veend;
+  //  ++ve){
+  //    if((!((*ve)->getNature() & Nature::SILHOUETTE)) || (!((*ve)->fedgeA()->isSmooth())))
+  //      continue;
+  //    FEdge *fe = (*ve)->fedgeA();
+  //    FEdge * fefirst = fe;
+  //    //ViewEdge::fedge_iterator fit = (*ve)->fedge_iterator_begin();
+  //    //ViewEdge::vertex_iterator vit = (*ve)->vertices_begin();
+  //    
+  //    Material mat;
+  //    //    for(; !(fe.end()); ++fe){
+  //    bool first = true;
+  //    bool front = true;
+  //    bool positive = true;
+  //    do{
+  //      FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+  //      Vec3r A((fes)->vertexA()->point3d());
+  //      Vec3r B((fes)->vertexB()->point3d());
+  //      Vec3r AB(B-A);
+  //      AB.normalize();
+  //      LineRep * lrep = new LineRep(A,B);
+  //      silhouetteDebugShape->AddRep(lrep);
+  //      Vec3r m((A+B)/2.0);
+  //      Vec3r crossP(AB^(fes)->normal()); 
+  //      crossP.normalize();
+  //      Vec3r viewvector(m-vp);
+  //      viewvector.normalize();
+  //      if(first){
+  //        if(((crossP)*(viewvector)) > 0)
+  //          positive = true;
+  //        else
+  //          positive = false;
+  //        first = false;
+  //      }
+  //      if(positive){
+  //        if(((crossP)*(viewvector)) < -0.2)
+  //          positive = false;
+  //      }else{
+  //        if(((crossP)*(viewvector)) > 0.2)
+  //          positive = true;
+  //      }
+  //      if(positive)
+  //        mat.setDiffuse(1,1,0,1);
+  //      else
+  //        mat.setDiffuse(1,0,0,1);
+  //      lrep->setMaterial(mat);
+  //      fe = fe->nextEdge();
+  //    }while((fe!=0) && (fe!=fefirst));
+  //  }
+  //====================================================================
+  // END FIXME GLDEBUG
+  
+  _pView->AddSilhouette(_SilhouetteNode);
+  //_pView->AddSilhouette(_WRoot);
+  //_pView->Add2DSilhouette(_ProjectedSilhouette);
+  //_pView->Add2DVisibleSilhouette(_VisibleProjectedSilhouette);  
+  _pView->AddDebug(_DebugNode);
+
+  // Draw the steerable density map:
+  //--------------------------------
+  if(_ComputeSteerableViewMap){
+    ComputeSteerableViewMap();
+  }
+  // Reset Style modules modification flags
+  resetModified(true);
+}
+
+void Controller::ComputeSteerableViewMap(){
+  if((!_Canvas) || (!_ViewMap))
+    return;
+
+  if(_ProgressBar){
+    _ProgressBar->reset();
+    _ProgressBar->setLabelText("Computing Steerable ViewMap");
+    _ProgressBar->setTotalSteps(3);
+    _ProgressBar->setProgress(0);
+  }
+    
+  // Build 4 nodes containing the edges in the 4 directions
+  NodeGroup *ng[Canvas::NB_STEERABLE_VIEWMAP];
+  unsigned i;
+  real c = 32.f/255.f; // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
+  for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP; ++i){
+    ng[i] = new NodeGroup;
+  }
+  NodeShape *completeNS = new NodeShape;
+  completeNS->material().setDiffuse(c,c,c,1);
+  ng[Canvas::NB_STEERABLE_VIEWMAP-1]->AddChild(completeNS);
+  SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  svm->Reset();
+
+  _pMainWindow->DisplayMessage("Dividing up edges");
+  ViewMap::fedges_container& fedges = _ViewMap->FEdges();
+  LineRep * fRep;
+  NodeShape *ns;
+  for(ViewMap::fedges_container::iterator f=fedges.begin(), fend=fedges.end();
+  f!=fend;
+  ++f){
+    if((*f)->viewedge()->qi() != 0)
+      continue;
+    fRep = new LineRep((*f)->vertexA()->point2d(),(*f)->vertexB()->point2d()) ;
+    completeNS->AddRep(fRep); // add to the complete map anyway
+    double *oweights = svm->AddFEdge(*f);
+    for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP-1; ++i){
+      ns = new NodeShape;
+      double wc = oweights[i]*c;
+      if(oweights[i] == 0)
+        continue;
+      ns->material().setDiffuse(wc, wc, wc, 1);
+      ns->AddRep(fRep);
+      ng[i]->AddChild(ns);
+    }
+  }
+  if(_ProgressBar)
+    _ProgressBar->setProgress(1);
+  _pMainWindow->DisplayMessage("Rendering Steerable ViewMap");
+  GrayImage *img[Canvas::NB_STEERABLE_VIEWMAP];
+  //#ifdef WIN32
+  QGLBasicWidget offscreenBuffer(_pView, "SteerableViewMap", _pView->width(), _pView->height()); 
+  QPixmap pm;
+  QImage qimg;
+  for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP; ++i){
+    offscreenBuffer.AddNode(ng[i]);
+    //img[i] = new GrayImage(_pView->width(), _pView->height());
+    //offscreenBuffer.readPixels(0,0,_pView->width(), _pView->height(), img[i]->getArray());
+    pm = offscreenBuffer.renderPixmap(_pView->width(), _pView->height());
+
+    if(pm.isNull())
+      cout << "BuildViewMap Warning: couldn't render the steerable ViewMap" << endl;
+    //pm.save(QString("steerable")+QString::number(i)+QString(".bmp"), "BMP");
+    // FIXME!! Lost of time !
+    qimg = pm.toImage();
+    // FIXME !! again!
+    img[i] = new GrayImage(_pView->width(), _pView->height());
+    for(unsigned y=0;y<img[i]->height();++y){
+      for(unsigned x=0;x<img[i]->width();++x){
+        //img[i]->setPixel(x,y,(float)qGray(qimg.pixel(x,y))/255.f);
+        img[i]->setPixel(x,y,(float)qGray(qimg.pixel(x,y)));
+        //        float c = qGray(qimg.pixel(x,y));
+        //        img[i]->setPixel(x,y,qGray(qimg.pixel(x,y)));
+      }
+    }
+    offscreenBuffer.DetachNode(ng[i]);
+    ng[i]->destroy();
+    delete ng[i];
+    // check
+    //    qimg = QImage(_pView->width(), _pView->height(), 32);
+    //    for(y=0;y<img[i]->height();++y){
+    //      for(unsigned x=0;x<img[i]->width();++x){
+    //        float v = img[i]->pixel(x,y);
+    //        qimg.setPixel(x,y,qRgb(v,v,v));
+    //      }
+    //    }
+    //    qimg.save(QString("newsteerable")+QString::number(i)+QString(".bmp"), "BMP");
+  }
+  //#else
+// 	// LINUX
+//   QGLBasicWidget offscreenBuffer(_pView, "SteerableViewMap", _pView->width(), _pView->height()); 
+
+//   float * buffer = 0;
+//   for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP; ++i){
+//     offscreenBuffer.AddNode(ng[i]);
+// 	offscreenBuffer.draw();
+//     img[i] = new GrayImage(_pView->width(), _pView->height());
+//     buffer = img[i]->getArray();
+//     offscreenBuffer.readPixels(0,0,_pView->width(), _pView->height(), buffer);
+//     for(unsigned y=0;y<img[i]->height();++y){
+//       for(unsigned x=0;x<img[i]->width();++x){
+//         img[i]->setPixel(x,y,255.f *img[i]->pixel(x,y));
+//       }
+//     }
+
+//     offscreenBuffer.DetachNode(ng[i]);
+//     ng[i]->destroy();
+//     delete ng[i];
+//   }
+// #endif
+  if(_ProgressBar)
+    _ProgressBar->setProgress(2);
+  _pMainWindow->DisplayMessage("Building Gaussian Pyramids");
+  svm->buildImagesPyramids(img,false,0,1.f);
+  if(_ProgressBar)
+    _ProgressBar->setProgress(3);
+}
+
+void Controller::saveSteerableViewMapImages(){
+  SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  if(!svm){
+    cerr << "the Steerable ViewMap has not been computed yet" << endl;
+    return;
+  }
+  svm->saveSteerableViewMap();
+}
+
+void Controller::toggleVisibilityAlgo() 
+{
+  if(_VisibilityAlgo == ViewMapBuilder::ray_casting) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+    _pMainWindow->DisplayMessage("Visibility algorithm switched to \"fast ray casting\"");
+  }
+  else if (_VisibilityAlgo == ViewMapBuilder::ray_casting_fast) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
+    _pMainWindow->DisplayMessage("Visibility algorithm switched to \"very fast ray casting\"");
+  }
+  else {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting;
+    _pMainWindow->DisplayMessage("Visibility algorithm switched to \"ray casting\"");
+  }
+}
+
+void Controller::setQuantitativeInvisibility(bool iBool)
+{
+  _EnableQI = iBool;
+}
+
+bool Controller::getQuantitativeInvisibility() const
+{
+  return _EnableQI;
+}
+
+void Controller::setComputeRidgesAndValleysFlag(bool iBool){
+  _ComputeRidges = iBool;
+}
+
+bool Controller::getComputeRidgesAndValleysFlag() const {
+  return _ComputeRidges;
+}
+void Controller::setComputeSuggestiveContoursFlag(bool b){
+  _ComputeSuggestive = b;
+}
+  
+bool Controller::getComputeSuggestiveContoursFlag() const {
+  return _ComputeSuggestive;
+}
+void Controller::setComputeSteerableViewMapFlag(bool iBool){
+  _ComputeSteerableViewMap = iBool;
+}
+
+bool Controller::getComputeSteerableViewMapFlag() const {
+  return _ComputeSteerableViewMap;
+}
+void Controller::setFrontBufferFlag(bool iBool)
+{
+  AppGLWidget::setFrontBufferFlag(iBool);
+}
+
+bool Controller::getFrontBufferFlag() const
+{
+  return AppGLWidget::getFrontBufferFlag();
+}
+
+void Controller::setBackBufferFlag(bool iBool)
+{
+  AppGLWidget::setBackBufferFlag(iBool);
+}
+
+bool Controller::getBackBufferFlag() const
+{
+  return AppGLWidget::getBackBufferFlag();
+}
+
+void Controller::DrawStrokes()
+{
+  if(_ViewMap == 0)
+    return;
+
+  _Chrono.start();
+  _Canvas->Draw();
+  real d = _Chrono.stop();
+  cout << "Strokes drawing  : " << d << endl;
+  resetModified();
+}
+
+void Controller::InsertStyleModule(unsigned index, const char *iFileName)
+{
+  QFileInfo fi(iFileName);
+  QString ext = fi.suffix();
+  if (ext != "py") {
+    cerr << "Error: Cannot load \"" << fi.fileName().toAscii().data()
+	 << "\", unknown extension" << endl;
+    return;
+  }
+  StyleModule* sm = new StyleModule(iFileName, _inter);
+  _Canvas->InsertStyleModule(index, sm);
+  
+}
+
+void Controller::AddStyleModule(const char *iFileName)
+{
+  _pStyleWindow->Add(iFileName);
+}
+
+void Controller::RemoveStyleModule(unsigned index)
+{
+  _Canvas->RemoveStyleModule(index);
+}
+
+void Controller::Clear()
+{
+  _Canvas->Clear();
+}
+
+void Controller::ReloadStyleModule(unsigned index, const char * iFileName)
+{
+  StyleModule* sm = new StyleModule(iFileName, _inter);
+  _Canvas->ReplaceStyleModule(index, sm);
+}
+
+void Controller::ExposeStyleWindow()
+{
+  _pStyleWindow->show();  
+}
+
+void Controller::ExposeOptionsWindow()
+{
+  _pOptionsWindow->show();
+}
+
+void Controller::ExposeHelpWindow()
+{
+	QStringList cmd_list = _browser_cmd.split(" ");
+  for (QStringList::iterator it = cmd_list.begin();
+       it != cmd_list.end();
+       ++it)
+    (*it).replace("%s", _help_index);
+  QProcess browser(0);
+  QString exe = cmd_list.first();
+  cmd_list.removeFirst();
+  browser.start(exe, cmd_list);
+}
+
+void Controller::ExposeAboutWindow()
+{
+  AppAboutWindow::display();
+}
+
+void Controller::SwapStyleModules(unsigned i1, unsigned i2)
+{
+  _Canvas->SwapStyleModules(i1, i2);
+}
+
+
+void Controller::toggleLayer(unsigned index, bool iDisplay)
+{
+  _Canvas->setVisible(index, iDisplay);
+  _pView->updateGL();
+}
+
+void Controller::setModified(unsigned index, bool iMod)
+{
+  _pStyleWindow->setModified(index, iMod);
+  _Canvas->setModified(index, iMod);
+  updateCausalStyleModules(index + 1);
+}
+
+void Controller::updateCausalStyleModules(unsigned index) {
+  vector<unsigned> vec;
+  _Canvas->causalStyleModules(vec, index);
+  for (vector<unsigned>::const_iterator it = vec.begin(); it != vec.end(); it++) {
+    _pStyleWindow->setModified(*it, true);
+    _Canvas->setModified(*it, true);
+  }
+}
+
+void Controller::saveSnapshot(bool b) {
+ _pView->saveSnapshot(b);
+}
+
+void Controller::savePSSnapshot(const QString& iFileName){
+  PSStrokeRenderer psRenderer((const char*)iFileName.toAscii().data());
+  _Canvas->Render(&psRenderer);
+  psRenderer.Close();
+}
+
+void Controller::saveTextSnapshot(const QString& iFileName){
+  TextStrokeRenderer textRenderer((const char*)iFileName.toAscii().data());
+  _Canvas->Render(&textRenderer);
+  textRenderer.Close();
+}
+
+void Controller::captureMovie() {
+ _pView->captureMovie();
+}
+
+void Controller::resetModified(bool iMod)
+{
+  _pStyleWindow->resetModified(iMod);
+  _Canvas->resetModified(iMod);
+}
+
+FEdge* Controller::SelectFEdge(real x, real y)
+{
+  if (!_ViewMap)
+    return NULL;
+
+  FEdge *fedge = (FEdge*)_ViewMap->GetClosestFEdge(x,y);
+  ViewEdge *selection = fedge->viewedge();
+  _pView->setSelectedFEdge(fedge);
+  _Canvas->setSelectedFEdge(fedge);
+  return fedge;
+}
+
+ViewEdge* Controller::SelectViewEdge(real x, real y)
+{
+  if (!_ViewMap)
+    return NULL;
+
+  FEdge *fedge = (FEdge*)_ViewMap->GetClosestFEdge(x,y);
+  ViewEdge *selection = fedge->viewedge();
+  _pView->setSelectedFEdge(fedge);
+  _Canvas->setSelectedFEdge(fedge);
+  return selection;
+}
+
+NodeGroup * Controller::BuildRep(vector<ViewEdge*>::iterator vedges_begin, 
+                                       vector<ViewEdge*>::iterator vedges_end)
+{
+  ViewMapTesselator2D tesselator2D;
+  Material mat;
+  mat.setDiffuse(1,1,0.3,1);
+  tesselator2D.setMaterial(mat);
+
+  return (tesselator2D.Tesselate(vedges_begin, vedges_end));
+}
+
+void Controller::toggleEdgeTesselationNature(Nature::EdgeNature iNature)
+{
+  _edgeTesselationNature ^= (iNature);
+  ComputeViewMap();
+}
+
+void		Controller::setModelsDir(const QString& dir) {
+  _current_dirs->setValue("models/dir", dir);
+}
+
+QString		Controller::getModelsDir() const {
+  QString dir = ".";
+  _current_dirs->getValue("models/dir", dir);
+  return dir;
+}
+
+void		Controller::setModulesDir(const QString& dir) {
+  _current_dirs->setValue("modules/dir", dir);
+}
+
+QString		Controller::getModulesDir() const {
+  QString dir = ".";
+  _current_dirs->getValue("modules/dir", dir);
+  return dir;
+}
+
+void		Controller::setPapersDir(const QString& dir) {
+  _current_dirs->setValue("papers/dir", dir);
+}
+
+QString		Controller::getPapersDir() const {
+  QString dir = Config::Path::getInstance()->getPapersDir();
+  _current_dirs->getValue("papers/dir", dir);
+  return dir;
+}
+
+void		Controller::setHelpIndex(const QString& index) {
+  _help_index = index;
+}
+
+QString		Controller::getHelpIndex() const {
+  return _help_index;
+}
+
+void		Controller::setBrowserCmd(const QString& cmd) {
+  _browser_cmd = cmd;
+}
+
+QString		Controller::getBrowserCmd() const {
+  return _browser_cmd;
+}
+
+void		Controller::resetInterpreter() {
+  if (_inter)
+    _inter->reset();
+}
+
+void Controller::displayMessage(const char * msg, bool persistent){
+  _pMainWindow->DisplayMessage(msg, persistent);
+}
+
+void Controller::displayDensityCurves(int x, int y){
+  SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  if(!svm)
+    return;
+
+  unsigned i,j;
+  typedef vector<Vec3r> densityCurve;
+  vector<densityCurve> curves(svm->getNumberOfOrientations()+1);
+  vector<densityCurve> curvesDirection(svm->getNumberOfPyramidLevels());
+
+  // collect the curves values
+  unsigned nbCurves = svm->getNumberOfOrientations()+1;
+  unsigned nbPoints = svm->getNumberOfPyramidLevels();
+  if(!nbPoints)
+    return;
+
+  // build the density/nbLevels curves for each orientation
+  for(i=0;i<nbCurves; ++i){
+    for(j=0; j<nbPoints; ++j){
+      curves[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(i, j, x, y), 0));
+    }
+  }
+  // build the density/nbOrientations curves for each level
+  for(i=0;i<nbPoints; ++i){
+    for(j=0; j<nbCurves; ++j){
+      curvesDirection[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(j, i, x, y), 0));
+    }
+  }
+
+  // display the curves
+  for(i=0; i<nbCurves; ++i)
+    _pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0,0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
+  for(i=1; i<=8; ++i)
+    _pDensityCurvesWindow->setLevelCurve(i, Vec2d(0,0), Vec2d(nbCurves, 1), curvesDirection[i], "orientation", "density");
+  _pDensityCurvesWindow->show();
+}
diff --git a/source/blender/freestyle/intern/app/Controller.h b/source/blender/freestyle/intern/app/Controller.h
new file mode 100755
index 00000000000..95b97ebcda3
--- /dev/null
+++ b/source/blender/freestyle/intern/app/Controller.h
@@ -0,0 +1,232 @@
+//
+//  Filename         : Controller.h
+//  Author           : Stephane Grabli
+//  Purpose          : The spinal tap of the system
+//  Date of creation : 01/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CONTROLLER_H
+# define CONTROLLER_H
+
+# include <string>
+# include "ConfigIO.h"
+# include "../geometry/FastGrid.h"
+# include "../geometry/HashGrid.h"
+# include "../view_map/ViewMapBuilder.h"
+# include "../system/TimeUtils.h"
+# include "../system/Precision.h"
+# include "../system/Interpreter.h"
+# include "../view_map/FEdgeXDetector.h"
+
+class AppProgressBar;
+class AppGLWidget;
+class AppMainWindow;
+class NodeGroup;
+class WShape;
+class SShape;
+class ViewMap;
+class ViewEdge;
+class AppCanvas;
+class InteractiveShader;
+class Shader;
+class AppInteractiveShaderWindow;
+class AppStyleWindow;
+class AppOptionsWindow;
+class AppDensityCurvesWindow;
+
+class Controller
+{
+public:
+  Controller() ;
+  ~Controller() ;
+  
+  void SetView(AppGLWidget *iView);
+  void SetMainWindow(AppMainWindow *iMainWindow); 
+  int  Load3DSFile(const char *iFileName);
+  void CloseFile();
+  void LoadViewMapFile(const char *iFileName, bool only_camera = false);
+  void SaveViewMapFile(const char *iFileName);
+  void ComputeViewMap();
+  void ComputeSteerableViewMap();
+  void saveSteerableViewMapImages();
+  void toggleEdgeTesselationNature(Nature::EdgeNature iNature);
+  void DrawStrokes();
+  void ExposeStyleWindow();
+  void ExposeOptionsWindow();
+  void ExposeHelpWindow();
+  void ExposeAboutWindow();
+  void SwapStyleModules(unsigned i1, unsigned i2);
+  void InsertStyleModule(unsigned index, const char *iFileName);
+  void AddStyleModule(const char *iFileName);
+  void RemoveStyleModule(unsigned index);
+  void ReloadStyleModule(unsigned index, const char * iFileName);
+  void Clear();
+  void toggleLayer(unsigned index, bool iDisplay);
+  void setModified(unsigned index, bool iMod);
+  void resetModified(bool iMod=false);
+  void updateCausalStyleModules(unsigned index);
+  void saveSnapshot(bool b = false);
+  void savePSSnapshot(const QString& iFileName);
+  void saveTextSnapshot(const QString& iFileName);
+  void captureMovie();
+  void displayMessage(const char *msg, bool persistent = false);
+  void displayDensityCurves(int x, int y);
+ 
+  
+  ViewEdge * SelectViewEdge(real x, real y);
+  FEdge * SelectFEdge(real x, real y);
+  NodeGroup* BuildRep(vector<ViewEdge*>::iterator vedges_begin, 
+		      vector<ViewEdge*>::iterator vedges_end) ;
+  
+  NodeGroup* debugNode() {return _DebugNode;}
+  AppGLWidget * view() {return _pView;}
+  NodeGroup* debugScene() {return _DebugNode;}
+  Grid& grid() {return _Grid;}
+  
+  void toggleVisibilityAlgo();
+
+  void setQuantitativeInvisibility(bool iBool); // if true, we compute quantitativeInvisibility
+  bool getQuantitativeInvisibility() const;
+
+  void setFrontBufferFlag(bool b);
+  bool getFrontBufferFlag() const;
+  void setBackBufferFlag(bool b);
+  bool getBackBufferFlag() const;
+
+  void setComputeRidgesAndValleysFlag(bool b);
+  bool getComputeRidgesAndValleysFlag() const ;
+  void setComputeSuggestiveContoursFlag(bool b);
+  bool getComputeSuggestiveContoursFlag() const ;
+
+  void setComputeSteerableViewMapFlag(bool iBool);
+  bool getComputeSteerableViewMapFlag() const;
+  void setSphereRadius(real s){_sphereRadius=s;}
+  real getSphereRadius() const {return _sphereRadius;}
+  void setSuggestiveContourKrDerivativeEpsilon(real dkr){_suggestiveContourKrDerivativeEpsilon=dkr;}
+  real getSuggestiveContourKrDerivativeEpsilon() const {return _suggestiveContourKrDerivativeEpsilon;}
+
+  AppProgressBar* getProgressBar(void) { return _ProgressBar; }
+
+  void		setModelsDir(const QString& dir);
+  QString	getModelsDir() const;
+  void		setModulesDir(const QString& dir);
+  QString	getModulesDir() const;
+  void		setPapersDir(const QString& dir);
+  QString	getPapersDir() const;
+  void		setHelpIndex(const QString& dir);
+  QString	getHelpIndex() const;
+  void		setBrowserCmd(const QString& cmd);
+  QString	getBrowserCmd() const;
+
+  void resetInterpreter();
+
+private:
+
+  // Main Window:
+  AppMainWindow *_pMainWindow;
+
+  // List of models currently loaded
+  vector<string> _ListOfModels;
+
+  // Current directories
+  ConfigIO* _current_dirs;
+
+  //View
+  // 3D
+  AppGLWidget *_pView;
+  
+  // 2D
+  //Viewer2DWindow *_pView2DWindow;
+  //Viewer2D *_pView2D;
+  
+  //Model
+  // Drawing Structure
+  NodeGroup *_RootNode;
+
+  // Winged-Edge structure
+  WingedEdge* _winged_edge;
+  
+  ViewMap * _ViewMap;
+
+  // Silhouette structure:
+  //std::vector<SShape*> _SShapes;
+  //NodeGroup *_SRoot;
+  
+  // Silhouette
+  NodeGroup *_SilhouetteNode;
+  NodeGroup *_ProjectedSilhouette;
+  NodeGroup *_VisibleProjectedSilhouette;
+  
+  // more Debug info
+  NodeGroup *_DebugNode;
+
+  // debug
+  //  NodeUser<ViewMap> *_ViewMapNode; // FIXME
+
+  // Chronometer:
+  Chronometer _Chrono;
+
+  // Progress Bar
+  AppProgressBar *_ProgressBar;
+
+  // edges tesselation nature
+  int _edgeTesselationNature;
+
+  FastGrid _Grid;
+  //HashGrid _Grid;
+  
+  unsigned int _SceneNumFaces;
+  real _minEdgeSize;
+  real _EPSILON;
+  real _bboxDiag;
+
+  AppCanvas *_Canvas;
+
+  AppStyleWindow *_pStyleWindow;
+  AppOptionsWindow *_pOptionsWindow;
+  AppDensityCurvesWindow *_pDensityCurvesWindow;
+
+  ViewMapBuilder::visibility_algo	_VisibilityAlgo;
+  
+  // Script Interpreter
+  Interpreter* _inter;
+
+  QString	_help_index;
+  QString	_browser_cmd;
+
+  bool _EnableQI;
+  bool _ComputeRidges;
+  bool _ComputeSuggestive;
+  real _sphereRadius;
+  real _suggestiveContourKrDerivativeEpsilon;
+
+  bool _ComputeSteerableViewMap;
+
+  FEdgeXDetector edgeDetector;
+};
+
+extern Controller	*g_pController;
+
+#endif // CONTROLLER_H
diff --git a/source/blender/freestyle/intern/app/Main.cpp b/source/blender/freestyle/intern/app/Main.cpp
new file mode 100755
index 00000000000..4f2556ed740
--- /dev/null
+++ b/source/blender/freestyle/intern/app/Main.cpp
@@ -0,0 +1,57 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <QApplication>
+#include <qgl.h>
+#include "Controller.h"
+#include "AppMainWindow.h"
+#include "AppConfig.h"
+
+// Global
+Controller	*g_pController;
+
+int main(int argc, char** argv)
+{
+  // sets the paths
+	QApplication::setColorSpec(QApplication::ManyColor);
+  QApplication *app = new QApplication(argc, argv);
+  Q_INIT_RESOURCE(freestyle);
+
+  Config::Path pathconfig;
+  
+  QGLFormat myformat;
+  myformat.setAlpha(true);
+  QGLFormat::setDefaultFormat( myformat );
+  
+  AppMainWindow mainWindow(NULL, "Freestyle");
+  //app->setMainWidget(mainWindow); // QT3
+
+  g_pController = new Controller;
+  g_pController->setMainWindow(&mainWindow);
+  g_pController->setView(mainWindow.pQGLWidget);
+  
+  mainWindow.show();
+
+  int res = app->exec();
+
+  delete g_pController;
+  
+  return res;
+}
diff --git a/source/blender/freestyle/intern/app/QGLBasicWidget.cpp b/source/blender/freestyle/intern/app/QGLBasicWidget.cpp
new file mode 100755
index 00000000000..0f690b67431
--- /dev/null
+++ b/source/blender/freestyle/intern/app/QGLBasicWidget.cpp
@@ -0,0 +1,141 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "QGLBasicWidget.h"
+#include "../rendering/GLRenderer.h"
+// #ifndef WIN32
+// #include "../rendering/pbuffer.h"
+// #endif 
+
+QGLBasicWidget::QGLBasicWidget( QWidget* parent, const char* name, int w, int h, const QGLWidget* shareWidget )
+    : QGLWidget( parent, shareWidget )
+{
+  _pGLRenderer = new GLRenderer;
+// #ifndef WIN32
+//   _Pbuffer = new PBuffer(w,h,
+//               PBuffer::SingleBuffer 
+// 			  | PBuffer::DepthBuffer 
+// 			  | PBuffer::StencilBuffer);
+
+//   _Pbuffer->create(false);
+// #endif 
+  resizeGL(w,h);
+  _RootNode.setLightingEnabled(false);
+  _RootNode.setLineWidth(1.0);
+}
+
+QGLBasicWidget::QGLBasicWidget( const QGLFormat& format, QWidget* parent, const char* name, 
+	      int w, int h, const QGLWidget* shareWidget )
+    : QGLWidget( format, parent, shareWidget )
+{
+  _pGLRenderer = new GLRenderer;
+// #ifndef WIN32
+//   _Pbuffer = new PBuffer(w,h,
+//               PBuffer::SingleBuffer 
+// 			  | PBuffer::DepthBuffer 
+// 			  | PBuffer::StencilBuffer);
+//   _Pbuffer->create(false);
+// #endif 
+  resizeGL(w,h);
+  _RootNode.setLightingEnabled(false);
+  _RootNode.setLineWidth(1.0);
+}
+
+QGLBasicWidget::~QGLBasicWidget()
+{
+  _RootNode.destroy();
+  if(_pGLRenderer)
+    delete _pGLRenderer;
+// #ifndef WIN32
+//   if(_Pbuffer)
+//     delete _Pbuffer;
+// #endif 
+}
+
+void QGLBasicWidget::AddNode(Node* iNode){
+  _RootNode.AddChild(iNode);
+}
+
+void QGLBasicWidget::DetachNode(Node* iNode){
+  _RootNode.DetachChild(iNode);
+}
+
+void QGLBasicWidget::readPixels(int x,
+                                int y,
+                                int width,
+                                int height,
+                                float *pixels){
+// #ifndef WIN32
+// _Pbuffer->makeCurrent();
+
+//    glReadBuffer(GL_FRONT);
+//    GLenum e = glGetError();
+//    GLenum glformat = GL_RED;
+//    glReadPixels(x,y,width, height, glformat, GL_FLOAT, (GLfloat*)pixels);
+//    e = glGetError();
+// #endif 
+} 
+
+void QGLBasicWidget::initializeGL()
+{
+   glClearColor(_clearColor[0],_clearColor[1],_clearColor[2],1);
+}
+
+void QGLBasicWidget::resizeGL( int w, int h )
+{
+// #ifndef WIN32
+// 	_Pbuffer->makeCurrent();
+// #endif 
+
+    glViewport( 0, 0, (GLint)w, (GLint)h );
+    // Projection Matrix
+    //==================
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+// #ifndef WIN32
+// 	// FXS- changed order of y bounds for glRead
+//     glOrtho(0,w, h, 0, -1.0, 1.0);
+// #else
+    glOrtho(0,w, 0, h, -1.0, 1.0);
+    //#endif 
+}
+
+void QGLBasicWidget::paintGL()
+{
+// #ifndef WIN32
+// 	_Pbuffer->makeCurrent();
+//    glClearColor(_clearColor[0],_clearColor[1],_clearColor[2],1);
+// #endif 
+
+  glDrawBuffer( GL_FRONT);
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+  //Modelview Matrix
+  //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+    
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_ONE, GL_ONE);
+  glDisable(GL_DEPTH_TEST);
+  _RootNode.accept(*_pGLRenderer);
+  glPopAttrib();
+}
+
diff --git a/source/blender/freestyle/intern/app/QGLBasicWidget.h b/source/blender/freestyle/intern/app/QGLBasicWidget.h
new file mode 100755
index 00000000000..9b29a641f28
--- /dev/null
+++ b/source/blender/freestyle/intern/app/QGLBasicWidget.h
@@ -0,0 +1,102 @@
+//
+//  Filename         : QGLBasicWidget.h
+//  Author           : Stephane Grabli
+//  Purpose          : A basic qgl widget designed to be used as 
+//                     a 2D offscreen buffer. (no interactive function)
+//  Date of creation : 26/12/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef QGLBASICWIDGET_H
+#define QGLBASICWIDGET_H
+
+#include <qgl.h>
+#include "../geometry/Geom.h"
+//#include "../rendering/pbuffer.h"
+#include "../scene_graph/NodeDrawingStyle.h"
+using namespace Geometry;
+
+class GLRenderer;
+class ViewMap;
+// #ifndef WIN32
+// class PBuffer;
+// #endif
+class QGLBasicWidget : public QGLWidget
+{
+    Q_OBJECT
+
+public:
+
+    QGLBasicWidget( QWidget* parent, const char* name, int w, int h, const QGLWidget* shareWidget=0 );
+    QGLBasicWidget( const QGLFormat& format, QWidget* parent, const char* name, 
+	  int w, int h, const QGLWidget* shareWidget=0 );
+    ~QGLBasicWidget();
+
+    /*! Adds a node directly under the root node */
+    void AddNode(Node* iNode);
+    /*! Detach the node iNode which must 
+     *  be directly under the root node.
+     */
+    void DetachNode(Node *iNode);
+
+    /*! reads the frame buffer pixels as luminance .
+     *  \param x 
+     *    The lower-left corner x-coordinate of the 
+     *    rectangle we want to grab.
+     *  \param y
+     *    The lower-left corner y-coordinate of the 
+     *    rectangle we want to grab.
+     *  \param width
+     *    The width of the rectangle we want to grab.
+     *  \param height
+     *    The height of the rectangle we want to grab.
+     *  \params pixels
+     *    The array of float (of size width*height) in which 
+     *    the read values are stored.
+     */
+    void readPixels(int x,int y,int width,int height,float *pixels) ;
+// #ifndef WIN32
+// 	void draw() { paintGL(); }
+// #endif 
+
+    inline void SetClearColor(const Vec3f& c) {_clearColor = c;}
+    inline Vec3f getClearColor() const {return _clearColor;}
+
+protected:
+
+    virtual void		initializeGL();
+    virtual void		paintGL();
+    virtual void		resizeGL(int w, int h);
+
+private:
+// #ifndef WIN32
+//   PBuffer	*_Pbuffer;
+// #endif 
+  NodeDrawingStyle       _RootNode;
+  Vec3f           _clearColor;
+  GLRenderer     *_pGLRenderer;
+};
+
+
+#endif // QGLBASICWIDGET_H
diff --git a/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.cpp b/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.cpp
new file mode 100755
index 00000000000..16ea53f157c
--- /dev/null
+++ b/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.cpp
@@ -0,0 +1,155 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "QStyleModuleSyntaxHighlighter.h"
+#include <QTextEdit>
+#include <QRegExp> 
+#include <iostream>
+using namespace std;
+
+QStyleModuleSyntaxHighlighter::QStyleModuleSyntaxHighlighter(QTextEdit *iTextEdit) 
+    : QSyntaxHighlighter(iTextEdit){
+  _operators.push_back("Operators");
+  _operators.push_back("select");
+  _operators.push_back("chain");
+  _operators.push_back("bidirectionalChain");
+  _operators.push_back("sequentialSplit");
+  _operators.push_back("recursiveSplit");
+  _operators.push_back("sort");
+  _operators.push_back("create");
+
+  _functors.push_back("StrokeShader");
+  _functors.push_back("UnaryPredicate1D");
+  _functors.push_back("UnaryPredicate0D");
+  _functors.push_back("BinaryPredicate1D");
+  _functors.push_back("ChainingIterator");
+  //  _functors.push_back("getName");
+  //  _functors.push_back("shade");
+  //  _functors.push_back("getObject");
+
+  _python.push_back("class ");
+  _python.push_back("from ");
+  _python.push_back("import ");
+  _python.push_back("__init__");
+  _python.push_back("__call__");
+  _python.push_back("def ");
+  _python.push_back("self");
+  _python.push_back("return");
+  //_python.push_back("print");
+  //  _python.push_back("for");
+  //  _python.push_back("if");
+  //  _python.push_back("while");
+  //  _python.push_back("range");
+  //  _python.push_back("in");
+
+	_defaultColor = iTextEdit->textColor();
+} 
+
+QStyleModuleSyntaxHighlighter::~QStyleModuleSyntaxHighlighter(){
+  _operators.clear();
+  _functors.clear();
+  _python.clear();
+}
+
+void QStyleModuleSyntaxHighlighter::highlightKeywords(const QString& text, vector<QString>& iKeywords, const QColor& iColor){
+  int pos = 0;
+  int pos1 = 0;
+  int pos2 = 0;
+  bool found = false;
+  for(vector<QString>::iterator o=iKeywords.begin(), oend=iKeywords.end();
+  o!=oend;
+  ++o){
+    pos =0;
+    QString word = *o;
+    while ( ( pos = text.indexOf(word,pos) ) != -1 ){
+      setFormat( pos , word.length() , iColor);
+      pos += text.length()+1;
+    }
+
+    //    while ( ( pos = text.find(QRegExp("(^|\\W)"+word+"\\W"),pos) ) != -1 ){
+    //      setFormat( pos , word.length()+1 , iColor);
+    //      pos += text.length()+1;
+    //    }
+  }
+}
+
+void QStyleModuleSyntaxHighlighter::dynamicHighlight(const QString& text){
+  int pos = 0;
+  int pos1 = 0;
+  int pos2 = 0;
+  while((pos1 = text.indexOf("class", pos, Qt::CaseSensitive) ) != -1 ){
+    int tmpPos = pos1+6;
+	if( ( pos2 = text.indexOf('(',tmpPos, Qt::CaseSensitive) ) != -1 ){
+      setFormat( tmpPos , pos2-tmpPos , QColor(0,0,255));
+      pos += pos2 - pos1+1;
+    } else{
+      setFormat( tmpPos, text.length()-tmpPos, QColor(0,0,255));
+      pos += text.length()+1;
+    }
+  }
+
+  while((pos1 = text.indexOf("def",pos, Qt::CaseSensitive) ) != -1 ){
+    int tmpPos = pos1+4;
+    if( ( pos2 = text.indexOf('(',tmpPos, Qt::CaseSensitive) ) != -1 ){
+      setFormat( tmpPos , pos2-tmpPos , QColor(136,0,0));
+      pos += pos2 - pos1+1;
+    } else{
+      setFormat( tmpPos, text.length()-tmpPos, QColor(136,0,0));
+      pos += text.length()+1;
+    }
+  }
+
+  pos = 0;
+  while((pos1 = text.indexOf("UnaryFunction", pos) ) != -1 ){
+    if( ( pos2 = text.indexOf(QRegExp("\\W"), pos1) ) != -1 ){
+      setFormat( pos1 , pos2-pos1 , QColor(0,0,255));
+      pos += pos2 - pos1+1;
+    } else{
+      setFormat( pos1, text.length()-pos1, QColor(0,0,255));
+      pos += text.length()+1;
+    }
+  }
+}
+
+void QStyleModuleSyntaxHighlighter::highlightComment(const QString& text){
+  int pos = 0;
+  int pos1 = 0;
+  int pos2 = 0;
+  while((pos1 = text.indexOf('#',pos, Qt::CaseSensitive) ) != -1 ){
+    if( ( pos2 = text.indexOf('\n',pos1, Qt::CaseSensitive) ) != -1 ){
+      setFormat( pos1 , pos2 , QColor(0,128,0));
+      pos += pos2 - pos1;
+      //setFormat( pos , text.length()-pos , _defaultColor );
+    } else{
+      setFormat( pos1 , text.length()-pos1, QColor(0,128,0));
+      pos += text.length()+1;
+    }
+  }
+}
+
+void QStyleModuleSyntaxHighlighter::highlightBlock ( const QString & text) {
+  setFormat( 0 , text.length() , _defaultColor );
+
+  highlightKeywords(text, _python, QColor(128,128,128));
+  highlightKeywords(text, _functors, QColor(136,0,0));
+  dynamicHighlight(text);
+  highlightKeywords(text, _operators, QColor(0,0,255));
+  highlightComment(text);
+}
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.h b/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.h
new file mode 100755
index 00000000000..ff3591ac45d
--- /dev/null
+++ b/source/blender/freestyle/intern/app/QStyleModuleSyntaxHighlighter.h
@@ -0,0 +1,57 @@
+//
+//  Filename         : QStyleModuleSyntaxHighlighter.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class to define the syntax highlighting
+//                     of the style module
+//  Date of creation : 07/01/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef QSTYLEMODULESYNTAXHIGHLIGHTER_H
+#define QSTYLEMODULESYNTAXHIGHLIGHTER_H
+
+#include <QSyntaxHighlighter>
+#include <vector>
+
+class QStyleModuleSyntaxHighlighter : public QSyntaxHighlighter
+{
+public:
+  QStyleModuleSyntaxHighlighter(QTextEdit *iTextEdit);
+  virtual ~QStyleModuleSyntaxHighlighter();
+  
+  virtual void highlightBlock ( const QString & text) ;
+  
+protected:
+  void highlightKeywords(const QString& text, std::vector<QString>& iKeywords, const QColor& iColor);
+  void dynamicHighlight(const QString& text);
+  void highlightComment(const QString& text);
+
+private:
+  std::vector<QString> _operators; 
+  std::vector<QString> _functors;
+  std::vector<QString> _python;
+  QColor _defaultColor; 
+};
+
+#endif
diff --git a/source/blender/freestyle/intern/app/app.pro b/source/blender/freestyle/intern/app/app.pro
new file mode 100755
index 00000000000..e2ba9aec6f7
--- /dev/null
+++ b/source/blender/freestyle/intern/app/app.pro
@@ -0,0 +1,179 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = app
+TARGET          = $${APPNAME}
+debug: TARGET   = $${TARGET}_d
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= console qglviewer2 3ds$${LIB3DS_VERSION_MAJ}.$${LIB3DS_VERSION_MIN} python$${PYTHON_VERSION_MAJ}.$${PYTHON_VERSION_MIN} glut
+win32: CONFIG	+= embed_manifest_exe 
+QT += xml
+
+exists (../libconfig.pri) {
+  include (../libconfig.pri)
+}
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+DESTDIR         = $${BUILD_DIR}/$${REL_DESTDIR}
+UI_DIR          = ui_dir
+
+#!win32:PYTHON_DIR_REL        = build/$${REL_DESTDIR}/lib/python
+#win32:PYTHON_DIR_REL        = build\\$${REL_DESTDIR}\\python
+  
+#
+# LIBS
+#
+#######################################
+
+!static {
+  !win32 {
+    lib_bundle {
+      LIBS += -F$${BUILD_DIR}/$${REL_DESTDIR}/lib -framework $${LIB_GEOMETRY} -framework $${LIB_IMAGE} \
+		-framework $${LIB_SCENE_GRAPH} -framework $${LIB_SYSTEM} \
+		-framework $${LIB_WINGED_EDGE} -framework $${LIB_VIEW_MAP} \
+		-framework $${LIB_RENDERING} -framework $${LIB_STROKE}
+    } else {
+      LIBS *= -L$${BUILD_DIR}/$${REL_DESTDIR}/lib \
+                     -l$${LIB_SYSTEM} -l$${LIB_IMAGE} -l$${LIB_GEOMETRY} \
+                     -l$${LIB_SCENE_GRAPH} -l$${LIB_WINGED_EDGE} -l$${LIB_VIEW_MAP} \
+                     -l$${LIB_RENDERING} -l$${LIB_STROKE}
+    }
+  }
+
+  win32:LIBS      *= $${DESTDIR}/$${LIB_SCENE_GRAPH}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_WINGED_EDGE}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_VIEW_MAP}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_STROKE}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_RENDERING}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+                     $${DESTDIR}/$${LIB_IMAGE}$${LIBVERSION}.lib
+}
+
+# irix-n32:LIBS           *= -l3ds -lglut -lQGLViewer -lpython$${PYTHON_VERSION_MAJ}.$${PYTHON_VERSION_MIN}
+# mac:LIBS                *= -framework GLUT -lobjc -l3ds -lm -lQGLViewer -lpython$${PYTHON_VERSION_MAJ}.$${PYTHON_VERSION_MIN}
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH             *= ../geometry ../image ../scene_graph ../stroke ../system \
+#                           ../view_map ../winged_edge ../rendering
+
+#
+# DEFINES
+#
+#######################################
+
+DEFINES                 *= APPNAME=\\\"$${APPNAME}\\\" \
+                           APPVERSION=\\\"$${APPVERSION}\\\" \
+                           #ROOT_DIR=\\"$(FREESTYLE_DIR)\\" \
+                           PYTHON_DIR_REL=\\\"$${PYTHON_DIR_REL}\\\"
+                                  
+#
+# MOC DIRECTORY
+#
+#######################################
+
+win32:MOCEXT            = win32
+linux-g++:MOCEXT        = linux
+cygwin-g++:MOCEXT       = cygwin
+irix-n32:MOCEXT         = irix
+mac:MOCEXT              = mac
+MOC_DIR                 = moc_$$MOCEXT
+
+#
+# INSTALL
+#
+#######################################
+
+EXE_DIR       = ../../
+# install library
+target.path   = $$EXE_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES, HEADERS & FORMS
+#
+#######################################
+
+
+static {
+  include(../system/src.pri)
+  include(../image/src.pri)
+  include(../geometry/src.pri)
+  include(../scene_graph/src.pri)
+  include(../winged_edge/src.pri)
+  include(../view_map/src.pri)
+  include(../stroke/src.pri)
+  include(../rendering/src.pri)
+}
+#include(src.pri)
+APP_DIR = ../app
+DEPENDPATH += .
+INCLUDEPATH += .
+
+FORMS += appmainwindowbase4.ui \
+         interactiveshaderwindow4.ui \
+         optionswindow4.ui \
+         progressdialog4.ui \
+         stylewindow4.ui \
+         densitycurveswindow4.ui
+RESOURCES += $${APP_DIR}/freestyle.qrc
+SOURCES *= $${APP_DIR}/AppAboutWindow.cpp \
+           $${APP_DIR}/AppCanvas.cpp \
+           $${APP_DIR}/AppConfig.cpp \
+           $${APP_DIR}/AppGLWidget.cpp \
+           $${APP_DIR}/AppInteractiveShaderWindow.cpp \
+           $${APP_DIR}/AppMainWindow.cpp \
+           $${APP_DIR}/AppOptionsWindow.cpp \
+           $${APP_DIR}/AppProgressBar.cpp \
+           $${APP_DIR}/AppStyleWindow.cpp \
+           $${APP_DIR}/Controller.cpp \
+           $${APP_DIR}/QGLBasicWidget.cpp \
+           $${APP_DIR}/QStyleModuleSyntaxHighlighter.cpp \
+           $${APP_DIR}/AppGL2DCurvesViewer.cpp \
+           $${APP_DIR}/AppDensityCurvesWindow.cpp \
+           $${APP_DIR}/ConfigIO.cpp \
+           $${APP_DIR}/Main.cpp
+
+HEADERS *= $${APP_DIR}/AppAboutWindow.h \
+           $${APP_DIR}/AppCanvas.h \
+           $${APP_DIR}/AppConfig.h \
+           $${APP_DIR}/AppGLWidget.h \
+           $${APP_DIR}/AppInteractiveShaderWindow.h \
+           $${APP_DIR}/AppMainWindow.h \
+           $${APP_DIR}/AppOptionsWindow.h \
+           $${APP_DIR}/AppProgressBar.h \
+           $${APP_DIR}/AppStyleWindow.h \
+           $${APP_DIR}/QGLBasicWidget.h \
+           $${APP_DIR}/QStyleModuleSyntaxHighlighter.h \
+           $${APP_DIR}/AppGL2DCurvesViewer.h \
+           $${APP_DIR}/AppDensityCurvesWindow.h \
+	   $${APP_DIR}/ConfigIO.h \
+           $${APP_DIR}/Controller.h
+
diff --git a/source/blender/freestyle/intern/app/appmainwindowbase4.ui b/source/blender/freestyle/intern/app/appmainwindowbase4.ui
new file mode 100755
index 00000000000..13e758d49dd
--- /dev/null
+++ b/source/blender/freestyle/intern/app/appmainwindowbase4.ui
@@ -0,0 +1,237 @@
+<ui version="4.0" >
+ <class>AppMainWindowBase</class>
+ <widget class="QMainWindow" name="AppMainWindowBase" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>510</width>
+    <height>523</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Freestyle</string>
+  </property>
+  <widget class="QWidget" name="centralwidget" >
+   <layout class="QGridLayout" >
+    <property name="margin" >
+     <number>9</number>
+    </property>
+    <property name="spacing" >
+     <number>6</number>
+    </property>
+    <item row="0" column="0" >
+     <layout class="QGridLayout" >
+      <property name="margin" >
+       <number>0</number>
+      </property>
+      <property name="spacing" >
+       <number>6</number>
+      </property>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar" >
+   <property name="geometry" >
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>510</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuHelp" >
+    <property name="title" >
+     <string>&amp;Help</string>
+    </property>
+    <addaction name="actionHelp" />
+    <addaction name="actionControlBindings" />
+    <addaction name="separator" />
+    <addaction name="actionAbout" />
+   </widget>
+   <widget class="QMenu" name="menuFile" >
+    <property name="title" >
+     <string>&amp;File</string>
+    </property>
+    <addaction name="actionOpen" />
+    <addaction name="actionSave" />
+    <addaction name="actionClose" />
+    <addaction name="separator" />
+    <addaction name="actionLoadCamera" />
+    <addaction name="separator" />
+    <addaction name="actionSaveSnapshot" />
+    <addaction name="actionSavePSSnapshot" />
+    <addaction name="actionSaveTextSnapshot" />
+    <addaction name="actionCaptureMovie" />
+    <addaction name="separator" />
+    <addaction name="actionQuit" />
+   </widget>
+   <widget class="QMenu" name="menuWindows" >
+    <property name="title" >
+     <string>&amp;Windows</string>
+    </property>
+    <addaction name="actionStyleModelerWindow" />
+    <addaction name="actionOptionsWindow" />
+   </widget>
+   <widget class="QMenu" name="menuTools" >
+    <property name="title" >
+     <string>&amp;Tools</string>
+    </property>
+    <addaction name="actionComputeViewMap" />
+    <addaction name="actionSaveDirectionalViewMapImages" />
+    <addaction name="actionComputeStrokes" />
+    <addaction name="separator" />
+    <addaction name="actionResetInterpreter" />
+   </widget>
+   <addaction name="menuFile" />
+   <addaction name="menuTools" />
+   <addaction name="menuWindows" />
+   <addaction name="menuHelp" />
+  </widget>
+  <widget class="QStatusBar" name="statusbar" />
+  <action name="actionOpen" >
+   <property name="text" >
+    <string>&amp;Open</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+O</string>
+   </property>
+  </action>
+  <action name="actionSave" >
+   <property name="text" >
+    <string>&amp;Save</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+S</string>
+   </property>
+  </action>
+  <action name="actionClose" >
+   <property name="text" >
+    <string>&amp;Close</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+C</string>
+   </property>
+  </action>
+  <action name="actionLoadCamera" >
+   <property name="text" >
+    <string>Load Camera</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+L</string>
+   </property>
+  </action>
+  <action name="actionSavePSSnapshot" >
+   <property name="text" >
+    <string>Save PS Snapshot...</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+P</string>
+   </property>
+  </action>
+  <action name="actionSaveSnapshot" >
+   <property name="text" >
+    <string>Save Snapshot</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+W</string>
+   </property>
+  </action>
+  <action name="actionSaveTextSnapshot" >
+   <property name="text" >
+    <string>Save Text Snapshot</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+T</string>
+   </property>
+  </action>
+  <action name="actionCaptureMovie" >
+   <property name="text" >
+    <string>Capture Movie</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+M</string>
+   </property>
+  </action>
+  <action name="actionQuit" >
+   <property name="text" >
+    <string>&amp;Quit</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+Q</string>
+   </property>
+  </action>
+  <action name="actionComputeViewMap" >
+   <property name="text" >
+    <string>Compute View Map</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+B</string>
+   </property>
+  </action>
+  <action name="actionSaveDirectionalViewMapImages" >
+   <property name="text" >
+    <string>Save Directional ViewMap Images</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+Shift+B</string>
+   </property>
+  </action>
+  <action name="actionComputeStrokes" >
+   <property name="text" >
+    <string>Compute Strokes</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+D</string>
+   </property>
+  </action>
+  <action name="actionResetInterpreter" >
+   <property name="text" >
+    <string>Reset Interpreter</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+R</string>
+   </property>
+  </action>
+  <action name="actionStyleModelerWindow" >
+   <property name="text" >
+    <string>Style Modeler Window</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+I</string>
+   </property>
+  </action>
+  <action name="actionOptionsWindow" >
+   <property name="text" >
+    <string>Options Window</string>
+   </property>
+   <property name="shortcut" >
+    <string>Alt+O</string>
+   </property>
+  </action>
+  <action name="actionHelp" >
+   <property name="text" >
+    <string>&amp;Help</string>
+   </property>
+   <property name="shortcut" >
+    <string>Ctrl+H</string>
+   </property>
+  </action>
+  <action name="actionControlBindings" >
+   <property name="text" >
+    <string>Control Bindings</string>
+   </property>
+   <property name="shortcut" >
+    <string>H</string>
+   </property>
+  </action>
+  <action name="actionAbout" >
+   <property name="text" >
+    <string>About</string>
+   </property>
+  </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/source/blender/freestyle/intern/app/densitycurveswindow4.ui b/source/blender/freestyle/intern/app/densitycurveswindow4.ui
new file mode 100755
index 00000000000..1a35e3247d1
--- /dev/null
+++ b/source/blender/freestyle/intern/app/densitycurveswindow4.ui
@@ -0,0 +1,442 @@
+<ui version="4.0" >
+ <class>DensityCurvesWindow</class>
+ <widget class="QDialog" name="DensityCurvesWindow" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>838</width>
+    <height>272</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Density Curves</string>
+  </property>
+  <layout class="QGridLayout" >
+   <property name="margin" >
+    <number>9</number>
+   </property>
+   <property name="spacing" >
+    <number>6</number>
+   </property>
+   <item row="0" column="0" >
+    <widget class="QTabWidget" name="tabWidget2" >
+     <property name="currentIndex" >
+      <number>1</number>
+     </property>
+     <widget class="QWidget" name="tab" >
+      <attribute name="title" >
+       <string>[ density / pyramid level ]  for each Orientation</string>
+      </attribute>
+      <layout class="QHBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <layout class="QVBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="AppGL2DCurvesViewer" native="1" name="CurvesViewer0" />
+         </item>
+         <item>
+          <widget class="QLabel" name="label0" >
+           <property name="text" >
+            <string>0 degree</string>
+           </property>
+           <property name="alignment" >
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <layout class="QVBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="AppGL2DCurvesViewer" native="1" name="CurvesViewer1" />
+         </item>
+         <item>
+          <widget class="QLabel" name="label_45" >
+           <property name="text" >
+            <string>45 degrees</string>
+           </property>
+           <property name="alignment" >
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <layout class="QVBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="AppGL2DCurvesViewer" native="1" name="CurvesViewer2" />
+         </item>
+         <item>
+          <widget class="QLabel" name="label90" >
+           <property name="text" >
+            <string>90 degrees</string>
+           </property>
+           <property name="alignment" >
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <layout class="QVBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="AppGL2DCurvesViewer" native="1" name="CurvesViewer3" />
+         </item>
+         <item>
+          <widget class="QLabel" name="label135" >
+           <property name="text" >
+            <string>135 degrees</string>
+           </property>
+           <property name="alignment" >
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <layout class="QVBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="AppGL2DCurvesViewer" native="1" name="CurvesViewer4" />
+         </item>
+         <item>
+          <widget class="QLabel" name="labelAll" >
+           <property name="text" >
+            <string>all directions</string>
+           </property>
+           <property name="alignment" >
+            <set>Qt::AlignCenter</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab" >
+      <attribute name="title" >
+       <string>[ density / orientation ]  for each Level</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <layout class="QHBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer1" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2" >
+             <property name="text" >
+              <string>level 1</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer2" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2" >
+             <property name="text" >
+              <string>level 2</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer3" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_2" >
+             <property name="text" >
+              <string>level 3</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer4" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_3" >
+             <property name="text" >
+              <string>level 4</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <layout class="QHBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer5" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_4" >
+             <property name="text" >
+              <string>level 5</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer6" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_5" >
+             <property name="text" >
+              <string>level 6</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer7" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_6" >
+             <property name="text" >
+              <string>level 7</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QVBoxLayout" >
+           <property name="margin" >
+            <number>0</number>
+           </property>
+           <property name="spacing" >
+            <number>6</number>
+           </property>
+           <item>
+            <widget class="AppGL2DCurvesViewer" native="1" name="LevelCurveViewer8" >
+             <property name="minimumSize" >
+              <size>
+               <width>50</width>
+               <height>50</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QLabel" name="label0_2_2_7" >
+             <property name="text" >
+              <string>level 8</string>
+             </property>
+             <property name="alignment" >
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11" />
+ <customwidgets>
+  <customwidget>
+   <class>AppGL2DCurvesViewer</class>
+   <extends>QWidget</extends>
+   <header>AppGL2DCurvesViewer.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/source/blender/freestyle/intern/app/freestyle.qrc b/source/blender/freestyle/intern/app/freestyle.qrc
new file mode 100755
index 00000000000..b37a6702af6
--- /dev/null
+++ b/source/blender/freestyle/intern/app/freestyle.qrc
@@ -0,0 +1,23 @@
+<!DOCTYPE RCC><RCC version="1.0">
+    <qresource prefix="/icons" >
+        <file>icons/add.png</file>
+        <file>icons/arrow_down.png</file>
+        <file>icons/arrow_left.png</file>
+        <file>icons/arrow_right.png</file>
+        <file>icons/arrow_up.png</file>
+        <file>icons/clear.png</file>
+        <file>icons/close.png</file>
+        <file>icons/edit.png</file>
+        <file>icons/eye0.png</file>
+        <file>icons/eye1.png</file>
+        <file>icons/folder.png</file>
+        <file>icons/home.png</file>
+        <file>icons/mod0.png</file>
+        <file>icons/mod1.png</file>
+        <file>icons/ok.png</file>
+        <file>icons/reload.png</file>
+        <file>icons/remove.png</file>
+        <file>icons/save.png</file>
+        <file>icons/save_as.png</file>
+    </qresource>
+</RCC>
diff --git a/source/blender/freestyle/intern/app/icons/add.png b/source/blender/freestyle/intern/app/icons/add.png
new file mode 100755
index 00000000000..d3388dcb3a9
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/add.png
diff --git a/source/blender/freestyle/intern/app/icons/arrow_down.png b/source/blender/freestyle/intern/app/icons/arrow_down.png
new file mode 100755
index 00000000000..6cf2e9bba26
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/arrow_down.png
diff --git a/source/blender/freestyle/intern/app/icons/arrow_left.png b/source/blender/freestyle/intern/app/icons/arrow_left.png
new file mode 100755
index 00000000000..72a5c462af6
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/arrow_left.png
diff --git a/source/blender/freestyle/intern/app/icons/arrow_right.png b/source/blender/freestyle/intern/app/icons/arrow_right.png
new file mode 100755
index 00000000000..f7e5c3b37e3
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/arrow_right.png
diff --git a/source/blender/freestyle/intern/app/icons/arrow_up.png b/source/blender/freestyle/intern/app/icons/arrow_up.png
new file mode 100755
index 00000000000..993a574b15a
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/arrow_up.png
diff --git a/source/blender/freestyle/intern/app/icons/clear.png b/source/blender/freestyle/intern/app/icons/clear.png
new file mode 100755
index 00000000000..1e3b2e37bd9
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/clear.png
diff --git a/source/blender/freestyle/intern/app/icons/close.png b/source/blender/freestyle/intern/app/icons/close.png
new file mode 100755
index 00000000000..2042ec3d1ba
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/close.png
diff --git a/source/blender/freestyle/intern/app/icons/edit.png b/source/blender/freestyle/intern/app/icons/edit.png
new file mode 100755
index 00000000000..244751b1933
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/edit.png
diff --git a/source/blender/freestyle/intern/app/icons/eye0.png b/source/blender/freestyle/intern/app/icons/eye0.png
new file mode 100755
index 00000000000..5f6d873cb0c
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/eye0.png
diff --git a/source/blender/freestyle/intern/app/icons/eye1.png b/source/blender/freestyle/intern/app/icons/eye1.png
new file mode 100755
index 00000000000..f762b66b482
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/eye1.png
diff --git a/source/blender/freestyle/intern/app/icons/folder.png b/source/blender/freestyle/intern/app/icons/folder.png
new file mode 100755
index 00000000000..3a99ad5ee92
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/folder.png
diff --git a/source/blender/freestyle/intern/app/icons/home.png b/source/blender/freestyle/intern/app/icons/home.png
new file mode 100755
index 00000000000..ec4b22098b2
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/home.png
diff --git a/source/blender/freestyle/intern/app/icons/mod0.png b/source/blender/freestyle/intern/app/icons/mod0.png
new file mode 100755
index 00000000000..816d814528a
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/mod0.png
diff --git a/source/blender/freestyle/intern/app/icons/mod1.png b/source/blender/freestyle/intern/app/icons/mod1.png
new file mode 100755
index 00000000000..c7c66183800
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/mod1.png
diff --git a/source/blender/freestyle/intern/app/icons/ok.png b/source/blender/freestyle/intern/app/icons/ok.png
new file mode 100755
index 00000000000..31c064ba922
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/ok.png
diff --git a/source/blender/freestyle/intern/app/icons/reload.png b/source/blender/freestyle/intern/app/icons/reload.png
new file mode 100755
index 00000000000..d26c280f1ac
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/reload.png
diff --git a/source/blender/freestyle/intern/app/icons/remove.png b/source/blender/freestyle/intern/app/icons/remove.png
new file mode 100755
index 00000000000..86d8c38a7f8
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/remove.png
diff --git a/source/blender/freestyle/intern/app/icons/save.png b/source/blender/freestyle/intern/app/icons/save.png
new file mode 100755
index 00000000000..932100d98e9
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/save.png
diff --git a/source/blender/freestyle/intern/app/icons/save_as.png b/source/blender/freestyle/intern/app/icons/save_as.png
new file mode 100755
index 00000000000..2c8b3f3e7b4
--- /dev/null
+++ b/source/blender/freestyle/intern/app/icons/save_as.png
diff --git a/source/blender/freestyle/intern/app/interactiveshaderwindow4.ui b/source/blender/freestyle/intern/app/interactiveshaderwindow4.ui
new file mode 100755
index 00000000000..e17442ad43e
--- /dev/null
+++ b/source/blender/freestyle/intern/app/interactiveshaderwindow4.ui
@@ -0,0 +1,103 @@
+<ui version="4.0" >
+ <class>InteractiveShaderWindow</class>
+ <widget class="QDialog" name="InteractiveShaderWindow" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>368</width>
+    <height>482</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>InteractiveShader</string>
+  </property>
+  <layout class="QVBoxLayout" >
+   <property name="margin" >
+    <number>9</number>
+   </property>
+   <property name="spacing" >
+    <number>6</number>
+   </property>
+   <item>
+    <widget class="QTextEdit" name="TextArea" />
+   </item>
+   <item>
+    <layout class="QHBoxLayout" >
+     <property name="margin" >
+      <number>0</number>
+     </property>
+     <property name="spacing" >
+      <number>6</number>
+     </property>
+     <item>
+      <widget class="QPushButton" name="OkButton" >
+       <property name="toolTip" >
+        <string>Save and close window</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/ok.png</iconset>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="SaveButton" >
+       <property name="toolTip" >
+        <string>Save module</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/save.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+S</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="SaveAsButton" >
+       <property name="toolTip" >
+        <string>Save module as</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/save_as.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+W</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="CancelButton" >
+       <property name="toolTip" >
+        <string>Close window</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/close.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+C</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11" />
+ <resources>
+  <include location="freestyle.qrc" />
+ </resources>
+ <connections/>
+</ui>
diff --git a/source/blender/freestyle/intern/app/optionswindow4.ui b/source/blender/freestyle/intern/app/optionswindow4.ui
new file mode 100755
index 00000000000..48c322c6d84
--- /dev/null
+++ b/source/blender/freestyle/intern/app/optionswindow4.ui
@@ -0,0 +1,651 @@
+<ui version="4.0" >
+ <class>OptionsWindow</class>
+ <widget class="QDialog" name="OptionsWindow" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>414</width>
+    <height>443</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Options</string>
+  </property>
+  <layout class="QVBoxLayout" >
+   <property name="margin" >
+    <number>9</number>
+   </property>
+   <property name="spacing" >
+    <number>6</number>
+   </property>
+   <item>
+    <widget class="QTabWidget" name="tabWidget" >
+     <property name="currentIndex" >
+      <number>4</number>
+     </property>
+     <widget class="QWidget" name="directoriesTab" >
+      <attribute name="title" >
+       <string>Directories</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <widget class="QGroupBox" name="modelsPathBox" >
+         <property name="title" >
+          <string>Models Path:</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLineEdit" name="modelsPathLineEdit" />
+            </item>
+            <item>
+             <widget class="QPushButton" name="modelPathAddButton" >
+              <property name="toolTip" >
+               <string>Add a folder to the path...</string>
+              </property>
+              <property name="text" >
+               <string/>
+              </property>
+              <property name="icon" >
+               <iconset resource="freestyle.qrc" >:/icons/icons/folder.png</iconset>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="patternsPathBox" >
+         <property name="title" >
+          <string>Patterns Path:</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLineEdit" name="patternsPathLineEdit" />
+            </item>
+            <item>
+             <widget class="QPushButton" name="patternsPathAddButton" >
+              <property name="toolTip" >
+               <string>Add a folder to the path...</string>
+              </property>
+              <property name="text" >
+               <string/>
+              </property>
+              <property name="icon" >
+               <iconset resource="freestyle.qrc" >:/icons/icons/folder.png</iconset>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="brushesPathBox" >
+         <property name="title" >
+          <string>Brushes Path:</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLineEdit" name="brushesPathLineEdit" />
+            </item>
+            <item>
+             <widget class="QPushButton" name="brushesPathAddButton" >
+              <property name="toolTip" >
+               <string>Add a folder to the path...</string>
+              </property>
+              <property name="text" >
+               <string/>
+              </property>
+              <property name="icon" >
+               <iconset resource="freestyle.qrc" >:/icons/icons/folder.png</iconset>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="pythonPathBox" >
+         <property name="title" >
+          <string>Python Path:</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLineEdit" name="pythonPathLineEdit" />
+            </item>
+            <item>
+             <widget class="QPushButton" name="pythonPathAddButton" >
+              <property name="toolTip" >
+               <string>Add a folder to the path...</string>
+              </property>
+              <property name="text" >
+               <string/>
+              </property>
+              <property name="icon" >
+               <iconset resource="freestyle.qrc" >:/icons/icons/folder.png</iconset>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="PaperTab" >
+      <attribute name="title" >
+       <string>Paper textures</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <widget class="QListWidget" name="paperTexturesList" />
+       </item>
+       <item>
+        <layout class="QHBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="QPushButton" name="addPaperTextureButton" >
+           <property name="toolTip" >
+            <string>Add Texture(s)</string>
+           </property>
+           <property name="text" >
+            <string/>
+           </property>
+           <property name="icon" >
+            <iconset resource="freestyle.qrc" >:/icons/icons/add.png</iconset>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="removePaperTextureButton" >
+           <property name="toolTip" >
+            <string>Remove Texture</string>
+           </property>
+           <property name="text" >
+            <string/>
+           </property>
+           <property name="icon" >
+            <iconset resource="freestyle.qrc" >:/icons/icons/remove.png</iconset>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="moveUpPaperTextureButton" >
+           <property name="toolTip" >
+            <string>Move up</string>
+           </property>
+           <property name="text" >
+            <string/>
+           </property>
+           <property name="icon" >
+            <iconset resource="freestyle.qrc" >:/icons/icons/arrow_up.png</iconset>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="moveDownPaperTextureButton" >
+           <property name="toolTip" >
+            <string>Move down</string>
+           </property>
+           <property name="text" >
+            <string/>
+           </property>
+           <property name="icon" >
+            <iconset resource="freestyle.qrc" >:/icons/icons/arrow_down.png</iconset>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="clearPaperTextureButton" >
+           <property name="toolTip" >
+            <string>Clear list</string>
+           </property>
+           <property name="text" >
+            <string/>
+           </property>
+           <property name="icon" >
+            <iconset resource="freestyle.qrc" >:/icons/icons/clear.png</iconset>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="featureLineTab" >
+      <attribute name="title" >
+       <string>Feature Lines</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <widget class="QGroupBox" name="curvaturesBox" >
+         <property name="title" >
+          <string>Curvatures</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="sphereRadiusLabel" >
+              <property name="text" >
+               <string>Sphere Radius (x mean edge size)</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLineEdit" name="sphereRadiusLineEdit" />
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="ridgesAndValleysBox" >
+         <property name="title" >
+          <string>Ridges and Valleys</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <widget class="QCheckBox" name="ridgeValleyCheckBox" >
+            <property name="text" >
+             <string>Compute Ridges and Valleys</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="suggestiveContoursBox" >
+         <property name="title" >
+          <string>Suggestive Contours</string>
+         </property>
+         <layout class="QVBoxLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item>
+           <widget class="QCheckBox" name="suggestiveContoursCheckBox" >
+            <property name="text" >
+             <string>Compute Suggestive Contours</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLabel" name="krEpsilonLabel" >
+              <property name="text" >
+               <string>kr Derivative Epsilon</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLineEdit" name="krEpsilonLineEdit" />
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="miscelleanousTab" >
+      <attribute name="title" >
+       <string>Miscelleanous</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <widget class="QGroupBox" name="viewMapBox" >
+         <property name="title" >
+          <string>View Map</string>
+         </property>
+         <layout class="QVBoxLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item>
+           <widget class="QCheckBox" name="asFloatCheckBox" >
+            <property name="text" >
+             <string>Save vector coordinates as floats</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="noOccluderListCheckBox" >
+            <property name="text" >
+             <string>Do not save occluders lists</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="steerableViewMapCheckBox" >
+            <property name="text" >
+             <string>Compute Steerable ViewMap</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="visibilityBox" >
+         <property name="title" >
+          <string>Visibility</string>
+         </property>
+         <layout class="QVBoxLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item>
+           <widget class="QCheckBox" name="qiCheckBox" >
+            <property name="text" >
+             <string>Enable Quantitative Invisibility</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="drawingBox" >
+         <property name="title" >
+          <string>Drawing</string>
+         </property>
+         <layout class="QVBoxLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item>
+           <widget class="QCheckBox" name="backBufferCheckBox" >
+            <property name="text" >
+             <string>Back Buffer</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="frontBufferCheckBox" >
+            <property name="text" >
+             <string>Front Buffer</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="helpTab" >
+      <attribute name="title" >
+       <string>Help</string>
+      </attribute>
+      <layout class="QVBoxLayout" >
+       <property name="margin" >
+        <number>9</number>
+       </property>
+       <property name="spacing" >
+        <number>6</number>
+       </property>
+       <item>
+        <layout class="QHBoxLayout" >
+         <property name="margin" >
+          <number>0</number>
+         </property>
+         <property name="spacing" >
+          <number>6</number>
+         </property>
+         <item>
+          <widget class="QLabel" name="browserCmdLabel" >
+           <property name="text" >
+            <string>Browser Command</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLineEdit" name="browserCmdLineEdit" />
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="helpBox" >
+         <property name="title" >
+          <string>Help index file:</string>
+         </property>
+         <layout class="QGridLayout" >
+          <property name="margin" >
+           <number>9</number>
+          </property>
+          <property name="spacing" >
+           <number>6</number>
+          </property>
+          <item row="0" column="0" >
+           <layout class="QHBoxLayout" >
+            <property name="margin" >
+             <number>0</number>
+            </property>
+            <property name="spacing" >
+             <number>6</number>
+            </property>
+            <item>
+             <widget class="QLineEdit" name="helpIndexPathLineEdit" />
+            </item>
+            <item>
+             <widget class="QPushButton" name="helpIndexPathButton" >
+              <property name="toolTip" >
+               <string>Browse</string>
+              </property>
+              <property name="text" >
+               <string/>
+              </property>
+              <property name="icon" >
+               <iconset resource="freestyle.qrc" >:/icons/icons/folder.png</iconset>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <spacer>
+         <property name="orientation" >
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" >
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" >
+     <property name="margin" >
+      <number>0</number>
+     </property>
+     <property name="spacing" >
+      <number>6</number>
+     </property>
+     <item>
+      <widget class="QPushButton" name="okButton" >
+       <property name="toolTip" >
+        <string>Save and close window</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/ok.png</iconset>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="applyButton" >
+       <property name="toolTip" >
+        <string>Save Options</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/save.png</iconset>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="closeButton" >
+       <property name="toolTip" >
+        <string>Close window</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/close.png</iconset>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="freestyle.qrc" />
+ </resources>
+ <connections/>
+</ui>
diff --git a/source/blender/freestyle/intern/app/progressdialog4.ui b/source/blender/freestyle/intern/app/progressdialog4.ui
new file mode 100755
index 00000000000..78cc67ed440
--- /dev/null
+++ b/source/blender/freestyle/intern/app/progressdialog4.ui
@@ -0,0 +1,26 @@
+<ui version="4.0" stdsetdef="1" >

+  <author></author>

+  <comment></comment>

+  <exportmacro></exportmacro>

+  <class>ProgressDialog</class>

+  <widget class="QDialog" name="ProgressDialog" >

+    <property name="geometry" >

+      <rect>

+        <x>0</x>

+        <y>0</y>

+        <width>350</width>

+        <height>64</height>

+      </rect>

+    </property>

+    <property name="windowTitle" >

+      <string>Progress Dialog</string>

+    </property>

+    <layout class="QGridLayout" >

+      <item row="0" column="0" >

+        <widget class="Q3ProgressBar" name="ProgressBar2" />

+      </item>

+    </layout>

+  </widget>

+  <layoutdefault spacing="6" margin="11" />

+  <pixmapfunction>qPixmapFromMimeSource</pixmapfunction>

+</ui>

diff --git a/source/blender/freestyle/intern/app/src.pri b/source/blender/freestyle/intern/app/src.pri
new file mode 100755
index 00000000000..2fcc9146216
--- /dev/null
+++ b/source/blender/freestyle/intern/app/src.pri
@@ -0,0 +1,50 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

+#			      W A R N I N G ! ! !                             #

+#             a u t h o r i z e d    p e r s o n a l    o n l y               #

+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

+

+APP_DIR = ../app

+

+SOURCES *= $${APP_DIR}/AppAboutWindow.cpp \

+           $${APP_DIR}/AppCanvas.cpp \

+           $${APP_DIR}/AppConfig.cpp \

+           $${APP_DIR}/AppGLWidget.cpp \

+           $${APP_DIR}/AppInteractiveShaderWindow.cpp \

+           $${APP_DIR}/AppMainWindow.cpp \

+           $${APP_DIR}/AppOptionsWindow.cpp \

+           $${APP_DIR}/AppProgressBar.cpp \

+           $${APP_DIR}/AppStyleWindow.cpp \

+           $${APP_DIR}/Controller.cpp \

+           $${APP_DIR}/QGLBasicWidget.cpp \

+           $${APP_DIR}/QStyleModuleSyntaxHighlighter.cpp \

+           $${APP_DIR}/AppGL2DCurvesViewer.cpp \

+           $${APP_DIR}/AppDensityCurvesWindow.cpp \

+           $${APP_DIR}/ConfigIO.cpp \

+           $${APP_DIR}/Main.cpp

+

+HEADERS *= $${APP_DIR}/AppAboutWindow.h \

+           $${APP_DIR}/AppCanvas.h \

+           $${APP_DIR}/AppConfig.h \

+           $${APP_DIR}/AppGLWidget.h \

+           $${APP_DIR}/AppInteractiveShaderWindow.h \

+           $${APP_DIR}/AppMainWindow.h \

+           $${APP_DIR}/AppOptionsWindow.h \

+           $${APP_DIR}/AppProgressBar.h \

+           $${APP_DIR}/AppStyleWindow.h \

+           $${APP_DIR}/QGLBasicWidget.h \

+           $${APP_DIR}/QStyleModuleSyntaxHighlighter.h \

+           $${APP_DIR}/AppGL2DCurvesViewer.h \

+           $${APP_DIR}/AppDensityCurvesWindow.h \

+	   $${APP_DIR}/ConfigIO.h \

+           $${APP_DIR}/Controller.h

+

+FORMS *= $${APP_DIR}/appmainwindowbase4.ui \

+         $${APP_DIR}/interactiveshaderwindow4.ui \

+         $${APP_DIR}/optionswindow4.ui \

+         $${APP_DIR}/progressdialog4.ui \

+         $${APP_DIR}/stylewindow4.ui \

+         $${APP_DIR}/densitycurveswindow4.ui

+

+RESOURCES = $${APP_DIR}/freestyle.qrc

+

+

diff --git a/source/blender/freestyle/intern/app/stylewindow4.ui b/source/blender/freestyle/intern/app/stylewindow4.ui
new file mode 100755
index 00000000000..c4ff5f656ae
--- /dev/null
+++ b/source/blender/freestyle/intern/app/stylewindow4.ui
@@ -0,0 +1,182 @@
+<ui version="4.0" >
+ <class>StyleWindow</class>
+ <widget class="QDialog" name="StyleWindow" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>571</width>
+    <height>421</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Style Modules</string>
+  </property>
+  <layout class="QVBoxLayout" >
+   <property name="margin" >
+    <number>9</number>
+   </property>
+   <property name="spacing" >
+    <number>6</number>
+   </property>
+   <item>
+    <widget class="QTableWidget" name="PlayList" >
+     <property name="dragEnabled" >
+      <bool>false</bool>
+     </property>
+     <property name="rowCount" >
+      <number>0</number>
+     </property>
+     <property name="columnCount" >
+      <number>3</number>
+     </property>
+     <column/>
+     <column/>
+     <column/>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" >
+     <property name="margin" >
+      <number>0</number>
+     </property>
+     <property name="spacing" >
+      <number>6</number>
+     </property>
+     <item>
+      <widget class="QPushButton" name="addButton" >
+       <property name="toolTip" >
+        <string>Add a Style Module</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/add.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+A</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="removeButton" >
+       <property name="toolTip" >
+        <string>Remove a Style Module</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/remove.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+R</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="moveUpButton" >
+       <property name="toolTip" >
+        <string>Move up</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/arrow_up.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+U</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="moveDownButton" >
+       <property name="toolTip" >
+        <string>Move down</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/arrow_down.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+D</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="editButton" >
+       <property name="toolTip" >
+        <string>Edit Style Module</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/edit.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+E</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="saveButton" >
+       <property name="toolTip" >
+        <string>Save Modules list</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/save.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+S</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="clearButton" >
+       <property name="toolTip" >
+        <string>Clear Modules list</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/clear.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+X</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="closeButton" >
+       <property name="toolTip" >
+        <string>Close window</string>
+       </property>
+       <property name="text" >
+        <string/>
+       </property>
+       <property name="icon" >
+        <iconset resource="freestyle.qrc" >:/icons/icons/close.png</iconset>
+       </property>
+       <property name="shortcut" >
+        <string>Ctrl+C</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources>
+  <include location="freestyle.qrc" />
+ </resources>
+ <connections/>
+</ui>
diff --git a/source/blender/freestyle/intern/app_blender/AppCanvas.cpp b/source/blender/freestyle/intern/app_blender/AppCanvas.cpp
new file mode 100755
index 00000000000..312a276f13d
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppCanvas.cpp
@@ -0,0 +1,406 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AppGLWidget.h"
+#include "../image/Image.h"
+#include "../system/TimeStamp.h"
+#include "Controller.h"
+#include "../stroke/StrokeRenderer.h"
+#include "AppCanvas.h"
+#include "../rendering/GLRenderer.h"
+#include "../rendering/GLStrokeRenderer.h"
+#include "../rendering/GLUtils.h"
+#include "AppConfig.h"
+
+#include "../system/StringUtils.h"
+
+#ifdef WIN32
+# include <windows.h>
+# include "../rendering/extgl.h"
+#endif
+#ifdef __MACH__
+# include <OpenGL/gl.h>
+#else
+# include <GL/gl.h>
+#endif
+
+AppCanvas::AppCanvas()
+:Canvas()
+{
+  _pViewer = 0;
+  _blendEquation = true;
+	_MapsPath = StringUtils::toAscii( Config::Path::getInstance()->getMapsDir() ).c_str();
+}
+
+AppCanvas::AppCanvas(AppGLWidget* iViewer)
+:Canvas()
+{
+  _pViewer = iViewer;
+  _blendEquation = true;
+}
+
+AppCanvas::AppCanvas(const AppCanvas& iBrother)
+:Canvas(iBrother)
+{
+  _pViewer = iBrother._pViewer;
+  _blendEquation = iBrother._blendEquation;
+}
+
+AppCanvas::~AppCanvas()
+{
+  _pViewer = 0;
+}
+
+void AppCanvas::setViewer(AppGLWidget *iViewer)
+{
+  _pViewer = iViewer;
+}  
+
+int AppCanvas::width() const 
+{
+  return _pViewer->width();
+}
+
+int AppCanvas::height() const
+{
+  return _pViewer->height();
+}
+
+BBox<Vec3r> AppCanvas::scene3DBBox() const 
+{
+  return _pViewer->scene3DBBox();
+}
+
+void AppCanvas::preDraw()
+{
+  Canvas::preDraw();
+
+  _pViewer->prepareCanvas();
+  glClearColor(0,0,0,0);
+	glClear(GL_COLOR_BUFFER_BIT);
+	glDisable(GL_LIGHTING);
+	glPolygonMode(GL_FRONT, GL_FILL);
+	glShadeModel(GL_SMOOTH);
+	glDisable(GL_DEPTH_TEST);
+	glEnable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+}
+
+void AppCanvas::init() 
+{
+#ifdef WIN32
+  static bool firsttime = true;
+  if (firsttime)
+    {
+      if (extgl_Initialize() != 0)
+	      cerr << "Error: problem occurred while initializing GL extensions" << endl;			
+      else
+	      cout << "GL extensions initialized" << endl;
+
+      if(!glutils_extgl_GetProcAddress("glBlendEquation")){
+        _blendEquation = false;
+        cout << "glBlendEquation unavailable on this hardware -> switching to strokes basic rendering mode" << endl;
+      }
+      firsttime=false;
+    }
+#endif
+
+  _Renderer = new GLStrokeRenderer;
+  if(!StrokeRenderer::loadTextures())
+    {
+      cerr << "unable to load stroke textures" << endl;
+      return;
+    }
+}
+
+void AppCanvas::postDraw()
+{
+  //inverse frame buffer
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+  _pViewer->releaseCanvas();
+
+  Canvas::postDraw();
+}
+
+void AppCanvas::Erase()
+{
+  Canvas::Erase();
+  //_pViewer->clear();
+}
+
+#include "../image/GaussianFilter.h"
+void AppCanvas::readColorPixels(int x,int y,int w, int h, RGBImage& oImage) const
+{
+  //static unsigned number = 0;
+  float *rgb = new float[3*w*h];
+  _pViewer->readPixels(x,y,w,h,AppGLWidget::RGB,rgb);
+  oImage.setArray(rgb, width(), height(), w,h, x, y, false);
+  // FIXME
+  //  QImage qtmp(w, h, 32);
+  //  for(unsigned py=0;py<h;++py){
+  //    for(unsigned px=0;px<w;++px){
+  //      int r = (int)255*(oImage.getR(x+px,y+py));
+  //      int g = (int)255*(oImage.getG(x+px,y+py));
+  //      int b = (int)255*(oImage.getB(x+px,y+py));
+  //      qtmp.setPixel(px,py,qRgb(r,g,b));
+  //    }
+  //  }
+  //  qtmp.save("densityQuery"+QString::number(number)+".png", "PNG");
+  //  if(number == 1090){
+  //    RGBImage img;
+  //    float *rgbtmp = new float[3*width()*height()];
+  //    _pViewer->readPixels(0,0,width(),height(),AppGLWidget::RGB,rgbtmp);
+  //    img.setArray(rgbtmp, width(), height(), width(), height(), 0, 0, false);
+  //    QImage qtmp(width(), height(), 32);
+  //    for(unsigned py=0;py<height();++py){
+  //      for(unsigned px=0;px<width();++px){
+  //        int r = (int)255*(img.getR(px,py));
+  //        int g = (int)255*(img.getG(px,py));
+  //        int b = (int)255*(img.getB(px,py));
+  //        qtmp.setPixel(px,height()-1-py,qRgb(r,g,b));
+  //      }
+  //    }
+  //    qtmp.save("densityQuery"+QString::number(number)+".png", "PNG");
+  //    
+  //    GaussianFilter filter;
+  //    filter.setSigma(4.0);
+  //    int bound = filter.getBound();
+  //    QImage qtmp2(width(), height(), 32);
+  //    for(int py2=0;py2<height();++py2){
+  //      for(int px2=0;px2<width();++px2){  
+  //        if( (px2-bound < 0) || (px2+bound>width())
+  //	      || (py2-bound < 0) || (py2+bound>height()))
+  //          continue;
+  //        int g = 255*filter.getSmoothedPixel<RGBImage>(&img, px2,py2);
+  //        qtmp2.setPixel(px2,height()-1-py2,qRgb(g,g,g));
+  //      }
+  //    }
+  //    qtmp2.save("blurredCausalDensity"+QString::number(number)+".png", "PNG");
+  //  }
+  //  cout << number << endl;
+  //  ++number;
+}
+
+void AppCanvas::readDepthPixels(int x,int y,int w, int h, GrayImage& oImage) const
+{
+  float *rgb = new float[w*h];
+  _pViewer->readPixels(x,y,w,h,AppGLWidget::DEPTH,rgb);
+  oImage.setArray(rgb, width(), height(), w,h, x, y, false);
+}
+
+void AppCanvas::update()
+{
+//  static int counter = 0;
+//  char fileName[100] = "framebuffer";
+//  char number[10];
+//
+  _pViewer->updateGL();
+  //_pViewer->swapBuffers();
+  //QImage fb = _pViewer->grabFrameBuffer();
+  //  sprintf(number, "%3d", counter);
+  //  strcat(fileName, number);
+  //  strcat(fileName, ".bmp");
+  //  fb.save(fileName, "BMP");
+  //counter++;
+}
+
+void AppCanvas::Render(const StrokeRenderer *iRenderer)
+{
+  if(!_blendEquation){
+    RenderBasic(iRenderer);
+    return;
+  }
+
+  glClearColor(1,1,1,1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  
+  if(_pViewer->draw3DsceneEnabled())
+  {
+    glClearColor(1,1,1,0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    
+    glEnable(GL_LIGHTING);
+    glEnable(GL_DEPTH_TEST);
+    _pViewer->set3DContext();
+    _pViewer->DrawScene(_pViewer->glRenderer());
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_LIGHTING);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+  }
+  
+  
+  glDisable(GL_DEPTH_TEST);
+  glBlendEquation(GL_ADD);
+  
+  glBlendFunc(GL_DST_COLOR, GL_ZERO);
+  
+  if(_drawPaper)
+  {
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    float zfar = _pViewer->zfar();
+    zfar = zfar+0.1*zfar;
+    //draw background paper // FIXME
+    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glBindTexture(GL_TEXTURE_2D, StrokeRenderer::_textureManager->getPaperTextureIndex(_paperTextureIndex)); 
+    glColor4f(1,1,1,0.0);
+    glBegin(GL_TRIANGLE_STRIP);
+    { 
+      glTexCoord2f(0,0); glVertex3f(0, 0, -1);
+      glTexCoord2f(4,0); glVertex3f(2048, 0, -1);
+      glTexCoord2f(0,4); glVertex3f(0, 2048, -1);
+      glTexCoord2f(4,4); glVertex3f(2048, 2048, -1);
+    } 
+    glEnd();
+  }
+  
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glBlendEquation(GL_FUNC_SUBTRACT);
+  glBlendFunc(GL_ONE, GL_ONE);
+  
+  glDisable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+  glColor4f(1,1,1,1);
+  glBegin(GL_TRIANGLE_STRIP);
+  {  
+    glVertex2f(0, 0);
+    glVertex2f(2048, 0);
+    glVertex2f(0, 2048);
+    glVertex2f(2048, 2048);
+  }  
+  glEnd();
+  glPopAttrib();
+  
+  glDisable(GL_DEPTH_TEST);
+  glBlendEquation(GL_ADD);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+  
+  glEnable(GL_TEXTURE_2D);
+
+  Canvas::Render(iRenderer);
+  //  
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glBlendEquation(GL_FUNC_SUBTRACT);
+  glBlendFunc(GL_ONE, GL_ONE);
+  
+  glDisable(GL_TEXTURE_2D);
+  glEnable(GL_BLEND);
+  glColor3f(1,1,1);
+  glBegin(GL_TRIANGLE_STRIP);
+  { 
+    glVertex2f(0, 0);
+    glVertex2f(2048, 0);
+    glVertex2f(0, 2048);
+    glVertex2f(2048, 2048);
+  } 
+  glEnd();
+  glPopAttrib();
+  
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+}
+
+void AppCanvas::RenderBasic(const StrokeRenderer *iRenderer)
+{
+  glClearColor(1,1,1,1);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  
+  if(_pViewer->draw3DsceneEnabled())
+  {
+    glClearColor(1,1,1,0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    
+    glEnable(GL_LIGHTING);
+    glEnable(GL_DEPTH_TEST);
+    _pViewer->set3DContext();
+    _pViewer->DrawScene(_pViewer->glRenderer());
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_LIGHTING);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+  }
+
+  glBlendFunc(GL_DST_COLOR, GL_ZERO);
+  if(_drawPaper)
+  {
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    float zfar = _pViewer->zfar();
+    zfar = zfar+0.1*zfar;
+    //draw background paper // FIXME
+    //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    glBindTexture(GL_TEXTURE_2D, StrokeRenderer::_textureManager->getPaperTextureIndex(_paperTextureIndex)); 
+    glColor4f(1,1,1,0.0);
+    glBegin(GL_TRIANGLE_STRIP);
+    { 
+      glTexCoord2f(0,0); glVertex3f(0, 0, -1);
+      glTexCoord2f(4,0); glVertex3f(2048, 0, -1);
+      glTexCoord2f(0,4); glVertex3f(0, 2048, -1);
+      glTexCoord2f(4,4); glVertex3f(2048, 2048, -1);
+    } 
+    glEnd();
+  }
+
+  glDisable(GL_DEPTH_TEST);
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  glEnable(GL_BLEND);
+  glPopAttrib();
+
+  glDisable(GL_DEPTH_TEST);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+  
+  glEnable(GL_TEXTURE_2D);
+  Canvas::RenderBasic(iRenderer);
+
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_BLEND);
+}
+
+
+void AppCanvas::RenderStroke(Stroke *iStroke) {
+  iStroke->Render(_Renderer);
+  if(_pViewer->getRecordFlag()){
+    //Sleep(1000);
+     _pViewer->saveSnapshot(true);
+  }
+}
diff --git a/source/blender/freestyle/intern/app_blender/AppCanvas.h b/source/blender/freestyle/intern/app_blender/AppCanvas.h
new file mode 100755
index 00000000000..0eb1faa2549
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppCanvas.h
@@ -0,0 +1,55 @@
+#ifndef ARTCANVAS_H
+#define ARTCANVAS_H
+
+#include "../stroke/Canvas.h"
+
+//class AppGLWidget;
+class AppCanvas : public Canvas
+{
+private:
+  mutable AppGLWidget *_pViewer;
+  bool _blendEquation;
+public:
+  AppCanvas();
+  AppCanvas(AppGLWidget *iViewer);
+  AppCanvas(const AppCanvas& iBrother);
+  virtual ~AppCanvas();
+
+  /*! operations that need to be done before a draw */
+  virtual void preDraw();
+  
+  /*! operations that need to be done after a draw */
+  virtual void postDraw();
+  
+  /*! Erases the layers and clears the canvas */
+  virtual void Erase(); 
+  
+  /* init the canvas */
+  virtual void init();
+  
+  /*! Reads a pixel area from the canvas */
+  virtual void readColorPixels(int x,int y,int w, int h, RGBImage& oImage) const;
+  /*! Reads a depth pixel area from the canvas */
+  virtual void readDepthPixels(int x,int y,int w, int h, GrayImage& oImage) const;
+
+  virtual BBox<Vec3r> scene3DBBox() const ;
+
+  /*! update the canvas (display) */
+  virtual void update() ;
+
+  /*! Renders the created strokes */
+  virtual void Render(const StrokeRenderer *iRenderer);
+  virtual void RenderBasic(const StrokeRenderer *iRenderer);
+  virtual void RenderStroke(Stroke *iStroke) ;
+
+  /*! accessors */
+  virtual int width() const ;
+  virtual int height() const ;
+  inline const AppGLWidget * viewer() const {return _pViewer;}
+
+  /*! modifiers */
+  void setViewer(AppGLWidget *iViewer) ;
+};
+
+
+#endif
diff --git a/source/blender/freestyle/intern/app_blender/AppConfig.cpp b/source/blender/freestyle/intern/app_blender/AppConfig.cpp
new file mode 100755
index 00000000000..37d139f54e3
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppConfig.cpp
@@ -0,0 +1,125 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AppConfig.h"
+#include <iostream>
+
+#include "../system/StringUtils.h"
+
+using namespace std;
+
+namespace Config{
+  Path* Path::_pInstance = 0;
+  Path::Path(){
+    // get the home directory
+    _HomeDir = getEnvVar("HOME");
+    // get the root directory
+	//soc
+	setRootDir(getEnvVar("FREESTYLE_BLENDER_DIR"));
+
+    _pInstance = this;
+  }
+  void Path::setRootDir(const string& iRootDir){
+    _ProjectDir = iRootDir;
+    _ModelsPath = "";
+    _PatternsPath = _ProjectDir +
+					     string(DIR_SEP.c_str()) +
+					     "data" +
+					     string(DIR_SEP.c_str()) +
+					     "textures" +
+					     string(DIR_SEP.c_str()) +
+					     "variation_patterns" +
+					     string(DIR_SEP.c_str());
+    _BrushesPath = _ProjectDir +
+					     string(DIR_SEP.c_str()) +
+					     "data" +
+					     string(DIR_SEP.c_str()) +
+					     "textures" +
+					     string(DIR_SEP.c_str()) +
+					     "brushes" +
+					     string(DIR_SEP.c_str());
+    _PythonPath = _ProjectDir + 
+              string(DIR_SEP.c_str()) + 
+              "python" + 
+              string(PATH_SEP.c_str()) +
+              _ProjectDir +
+				string(DIR_SEP.c_str()) +
+              "style_modules" +
+              string(DIR_SEP.c_str()) ;
+    if (getenv("PYTHONPATH")) {
+      _PythonPath += string(PATH_SEP.c_str()) + string(getenv("PYTHONPATH"));
+    }
+#ifdef WIN32
+    _BrowserCmd = "C:\\Program Files\\Internet Explorer\\iexplore.exe %s";
+#else
+    _BrowserCmd = "mozilla %s";
+#endif
+    _HelpIndexPath = _ProjectDir +
+					  string(DIR_SEP.c_str()) +
+					  "doc" +
+					  string(DIR_SEP.c_str()) +
+					  "html" +
+					  string(DIR_SEP.c_str()) +
+					  "index.html";
+    _PapersDir = _ProjectDir +
+					  string(DIR_SEP.c_str()) +
+					  "data" +
+					  string(DIR_SEP.c_str()) +
+					  "textures" +
+					  string(DIR_SEP.c_str()) +
+					  "papers" +
+					  string(DIR_SEP.c_str());
+    _EnvMapDir = _ProjectDir +
+				   string(DIR_SEP.c_str()) +
+				   "data" +
+				   string(DIR_SEP.c_str()) +
+				   "env_map" +
+				   string(DIR_SEP.c_str());
+    _MapsDir = _ProjectDir +
+				   string(DIR_SEP.c_str()) +
+				   "data" +
+           string(DIR_SEP.c_str()) +
+				   "maps" +
+				   string(DIR_SEP.c_str());
+  }
+  void Path::setHomeDir(const string& iHomeDir){
+    _HomeDir = iHomeDir;
+  }
+  Path::~Path(){
+    _pInstance = 0;
+  }
+  Path* Path::getInstance() {
+    return _pInstance;
+  }
+  string Path::getEnvVar(const string& iEnvVarName){
+    string value;
+	if (!getenv( StringUtils::toAscii(iEnvVarName).c_str() ) ) {
+      cerr << "Warning: You may want to set the $"<< StringUtils::toAscii(iEnvVarName)
+		  << " environment variable to use " << string(Config::APPLICATION_NAME) << "." << endl
+	    << "         Otherwise, the current directory will be used instead." << endl;
+      value = ".";
+    }else{
+      value = getenv( StringUtils::toAscii(iEnvVarName).c_str()  );
+    } 
+    return value;
+  }
+
+} // End of namepace Config
+
diff --git a/source/blender/freestyle/intern/app_blender/AppConfig.h b/source/blender/freestyle/intern/app_blender/AppConfig.h
new file mode 100755
index 00000000000..8a6fef746dc
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppConfig.h
@@ -0,0 +1,111 @@
+//
+//  Filename         : AppConfig.h
+//  Author           : Emmanuel Turquin
+//  Purpose          : Configuration file
+//  Date of creation : 26/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  APP_CONFIG_H
+# define APP_CONFIG_H
+
+# include <string>
+# include "../system/FreestyleConfig.h"
+# include "../system/Precision.h"
+
+using namespace std;
+
+namespace Config {
+
+  class Path{
+  protected:
+    static Path * _pInstance;
+    string _ProjectDir;
+    string _ModelsPath;
+    string _PatternsPath;
+    string _BrushesPath;
+    string _PythonPath;
+    string _BrowserCmd;
+    string _HelpIndexPath;
+    string _PapersDir;
+    string _EnvMapDir;
+    string _MapsDir;
+    string _HomeDir;
+  public:
+    Path();
+    virtual ~Path();
+    static Path* getInstance();
+
+    void setRootDir(const string& iRootDir) ;
+    void setHomeDir(const string& iHomeDir) ;
+
+    const string& getProjectDir() const {return _ProjectDir;}
+    const string& getModelsPath() const {return _ModelsPath;}
+    const string& getPatternsPath() const {return _PatternsPath;}
+    const string& getBrushesPath() const {return _BrushesPath;}
+    const string& getPythonPath() const {return _PythonPath;}
+    const string& getBrowserCmd() const {return _BrowserCmd;}
+    const string& getHelpIndexpath() const {return _HelpIndexPath;}
+    const string& getPapersDir() const {return _PapersDir;}
+    const string& getEnvMapDir() const {return _EnvMapDir;}
+    const string& getMapsDir() const {return _MapsDir;}
+    const string& getHomeDir() const {return _HomeDir;}
+
+    static string getEnvVar(const string& iEnvVarName);
+    
+  };
+
+  //
+  // Configuration, default values
+  //
+  //////////////////////////////////////////////////////////////
+
+  // Application
+  static const string APPLICATION_NAME("APPNAME");
+  static const string APPLICATION_VERSION("APPVERSION");
+
+  // ViewMap
+  static const string VIEWMAP_EXTENSION("vm");
+  static const string VIEWMAP_MAGIC("ViewMap File");
+  static const string VIEWMAP_VERSION("1.9");
+
+  // Style modules
+  static const string STYLE_MODULE_EXTENSION("py");
+  static const string STYLE_MODULES_LIST_EXTENSION("sml");
+
+  // Options
+  static const string OPTIONS_DIR("." + APPLICATION_NAME);
+  static const string OPTIONS_FILE("options.xml");
+  static const string OPTIONS_CURRENT_DIRS_FILE("current_dirs.xml");
+  static const string OPTIONS_QGLVIEWER_FILE("qglviewer.xml");
+
+  // Default options
+  static const real DEFAULT_SPHERE_RADIUS = 1.0;
+  static const real DEFAULT_DKR_EPSILON = 0.0;
+
+  // Papers
+  static const string DEFAULT_PAPER_TEXTURE("whitepaper.jpg");
+
+
+} // End of namepace Config
+
+#endif // APP_CONFIG_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget.cpp
new file mode 100755
index 00000000000..fba019f8372
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget.cpp
@@ -0,0 +1,634 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include "../stroke/Canvas.h"
+#include "AppGLWidget.h"
+#include "../scene_graph/NodeLight.h"
+#include "../rendering/GLRenderer.h"
+#include "../rendering/GLSelectRenderer.h"
+#include "../rendering/GLBBoxRenderer.h"
+#include "../rendering/GLMonoColorRenderer.h"
+#include "Controller.h"
+#include "../view_map/Silhouette.h"
+#include "../view_map/ViewMap.h"
+#include "../scene_graph/LineRep.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/VertexRep.h"
+#include "AppConfig.h"
+
+#include "../system/StringUtils.h"
+
+extern "C" {
+#include "BLI_blenlib.h"
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+}
+
+// glut.h must be included last to avoid a conflict with stdlib.h on vc .net 2003 and 2005
+#ifdef __MACH__
+# include <GLUT/glut.h>
+#else
+# include <GL/glut.h>
+#endif
+
+GLuint texture = 0;
+
+bool AppGLWidget::_frontBufferFlag = false;
+bool AppGLWidget::_backBufferFlag = true;
+
+AppGLWidget::AppGLWidget(const char *iName)
+{
+  //soc
+  _camera = new AppGLWidget_Camera;	
+
+  _Fovy        = 30.f;
+  //_SceneDepth = 2.f;
+  _RenderStyle = LINE;
+  //_ModelRootNode->setBBox(BBox<Vec3f>(Vec3f(-10.f, -10.f, -10.f), Vec3f(10.f, 10.f, 10.f)));
+  _ModelRootNode = new NodeDrawingStyle;
+  _SilhouetteRootNode = new NodeDrawingStyle;
+  _DebugRootNode = new NodeDrawingStyle;
+  
+  _RootNode.AddChild(_ModelRootNode);
+  _SilhouetteRootNode->setStyle(DrawingStyle::LINES);
+  _SilhouetteRootNode->setLightingEnabled(false);
+  _SilhouetteRootNode->setLineWidth(2.f);
+  _SilhouetteRootNode->setPointSize(3.f);
+
+  _RootNode.AddChild(_SilhouetteRootNode);
+
+  _DebugRootNode->setStyle(DrawingStyle::LINES);
+  _DebugRootNode->setLightingEnabled(false);
+  _DebugRootNode->setLineWidth(1.f);
+  
+  _RootNode.AddChild(_DebugRootNode);
+
+  _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+  _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+
+  _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+  _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+
+  _camera->setZNearCoefficient(0.1);
+
+  // 2D Scene
+  //  _pFENode = new NodeDrawingStyle;
+  //  _pFENode->setStyle(DrawingStyle::LINES);
+  //  _pFENode->setLightingEnabled(false);
+  //  _pFENode->setLineWidth(1.f);
+  //
+  //  _p2DNode.AddChild(_pFENode);
+  //  
+  //  _pVisibleSilhouetteNode = new NodeDrawingStyle;
+  //  _pVisibleSilhouetteNode->setStyle(DrawingStyle::LINES);
+  //  _pVisibleSilhouetteNode->setLightingEnabled(false);
+  //  _pVisibleSilhouetteNode->setLineWidth(3.f);
+  //
+  //  _p2DNode.AddChild(_pVisibleSilhouetteNode);
+  //  
+  _p2DSelectionNode = new NodeDrawingStyle;
+  _p2DSelectionNode->setLightingEnabled(false);
+  _p2DSelectionNode->setStyle(DrawingStyle::LINES);
+  _p2DSelectionNode->setLineWidth(5.f);
+  
+  _p2DNode.AddChild(_p2DSelectionNode);
+
+  _pGLRenderer = new GLRenderer;
+  _pSelectRenderer = new GLSelectRenderer;
+  _pBBoxRenderer = new GLBBoxRenderer;
+  _pMonoColorRenderer = new GLMonoColorRenderer;
+  _pDebugRenderer = new GLDebugRenderer;
+
+  _pMainWindow = NULL;
+  _cameraStateSaved = false;
+  _drawBBox = false;
+  _silhouette = false;
+  _fedges = false;
+  _debug = false;
+  _selection_mode = false;
+  _Draw2DScene = true;
+  _Draw3DScene = false;
+  _drawEnvMap = false;
+  _currentEnvMap = 1;
+  _maxId = 0;
+  _blendFunc = 0;
+
+  const string sep(Config::DIR_SEP);
+  const string filename = Config::Path::getInstance()->getHomeDir() + sep +
+    Config::OPTIONS_DIR + sep + Config::OPTIONS_QGLVIEWER_FILE;
+  setStateFileName(filename);  
+
+  //get camera frame:
+  //qglviewer::Camera * cam = camera();
+  //qglviewer::ManipulatedFrame *  fr = cam->frame() ;
+  
+  //soc _enableupdateSilhouettes = false;
+
+  _captureMovie = false;
+  //  _frontBufferFlag = false;
+  //  _backBufferFlag = true;
+  _record = false;
+
+
+	workingBuffer = GL_BACK; //soc
+
+}
+
+AppGLWidget::~AppGLWidget()
+{
+  int ref = _RootNode.destroy();
+  
+  _Light.destroy();
+  ref = _p2DNode.destroy();
+  
+  if(NULL != _pGLRenderer)
+    {
+      delete _pGLRenderer;
+      _pGLRenderer = NULL;
+    }
+
+  if(NULL != _pSelectRenderer)
+    {
+      delete _pSelectRenderer;
+      _pSelectRenderer = NULL;
+    }
+
+  if(NULL != _pBBoxRenderer)
+    {
+      delete _pBBoxRenderer;
+      _pBBoxRenderer = NULL;
+    }
+
+  if(NULL != _pMonoColorRenderer)
+    {
+      delete _pMonoColorRenderer;
+      _pMonoColorRenderer = NULL;
+    }
+
+  if(NULL != _pDebugRenderer)
+    {
+      delete _pDebugRenderer;
+      _pDebugRenderer = NULL;
+    }
+
+  makeCurrent();
+  //saveToFile(filename);
+}
+
+
+
+void AppGLWidget::LoadEnvMap(const char *filename)
+{
+  GLuint textureId;
+  //sgiImage img;
+  //cout << filename << endl;
+	ImBuf *image = IMB_loadiffname(filename, 0);
+
+  //data = img.read(filename); // tres beau bleu gris mauve!!
+  // allocate a texture name
+  glGenTextures( 1, &textureId );
+  if(textureId > (GLuint) _maxId)
+    _maxId = textureId;
+
+  // select our current texture
+  glBindTexture( GL_TEXTURE_2D, textureId );
+  
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
+                   GL_NEAREST);
+
+  glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, image->x, image->y, 0,
+    GL_RGBA, GL_UNSIGNED_BYTE, image->rect );
+}
+
+void AppGLWidget::init()
+{
+  //setShortcut(QGLViewer::EXIT_VIEWER, 0);
+//  setShortcut(QGLViewer::DISPLAY_Z_BUFFER, 0);
+  //setShortcut(QGLViewer::STEREO, 0);
+  //setShortcut(QGLViewer::ANIMATION, 0);
+  //setShortcut(QGLViewer::EDIT_CAMERA, 0);
+
+  //restoreStateFromFile();
+
+  //trackball().fitBBox(_ModelRootNode->bbox().getMin(), _ModelRootNode->bbox().getMax(), _Fovy);
+
+   glClearColor(1,1,1,0);
+   glShadeModel(GL_SMOOTH);
+  
+   glCullFace(GL_BACK);
+   glEnable(GL_CULL_FACE);
+   glEnable(GL_DEPTH_TEST);
+
+   // open and read texture data
+   Config::Path * cpath = Config::Path::getInstance();
+   string envmapDir = cpath->getEnvMapDir();
+	LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray00.png")).c_str() );
+   //LoadEnvMap(Config::ENV_MAP_DIR + "gray01.bmp");
+   LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray02.png")).c_str() );
+   LoadEnvMap( StringUtils::toAscii(envmapDir + string("gray03.png")).c_str() );
+   LoadEnvMap( StringUtils::toAscii(envmapDir + string("brown00.png")).c_str() );
+   glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
+   glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP) ;
+
+   // gl settings for Environmental Texturing:
+   glColor3f(1, 1, 1);
+
+   // Use GL auto-computed enviroment texture coordinates
+   //glEnable(GL_TEXTURE_GEN_S);
+   //glEnable(GL_TEXTURE_GEN_T);
+
+   // Bind the texture to use
+   //glBindTexture(GL_TEXTURE_2D,texture);
+   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+   //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+   
+   // parametres de melange
+   //glBlendFunc(GL_ONE, GL_ONE);
+   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+   //glBlendEquatio(GL_FUNC_ADD);
+     
+   //glEnable(GL_BLEND);
+   NodeLight *light = new NodeLight;
+   _Light.AddChild(light);
+
+   // Change QGLViewer's default shortcut for snapshots
+   //setShortcut(QGLViewer::SAVE_SCREENSHOT, Qt::CTRL + Qt::Key_W);
+   //   setShortcutKey (QGLViewer::SAVE_SCREENSHOT, Key_W);
+   //   setShortcutStateKey(QGLViewer::SAVE_SCREENSHOT, ControlButton);
+  
+   cout << "Renderer (GL)    : " << glGetString(GL_RENDERER) << endl
+	<< "Vendor (GL)      : " << glGetString(GL_VENDOR) << endl << endl;
+}
+
+void AppGLWidget::draw()
+{
+  if (true == _Draw3DScene)
+    {
+      if (true == _selection_mode) {
+	_pSelectRenderer->setSelectRendering(false);
+	_pSelectRenderer->resetColor();
+	DrawScene(_pSelectRenderer);
+      } else
+ 	DrawScene(_pGLRenderer);
+  
+      if (true == _silhouette)
+	DrawSilhouette();
+  
+      if (true == _drawBBox) {
+	glPushAttrib(GL_ALL_ATTRIB_BITS);
+	_ModelRootNode->accept(*_pBBoxRenderer);
+	glPopAttrib();
+      }
+
+      if (true == _debug) {
+	glPushAttrib(GL_ALL_ATTRIB_BITS);
+	_DebugRootNode->accept(*_pDebugRenderer);
+	glPopAttrib();
+      }
+    }
+
+  if (true == _Draw2DScene) {
+    Draw2DScene(_pGLRenderer);
+    set3DContext();
+  }
+  if(_record){
+    saveSnapshot(true);
+  }
+}
+
+void AppGLWidget::DrawScene(SceneVisitor *iRenderer)
+{
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+  if(_drawEnvMap)
+  {
+    _ModelRootNode->setLightingEnabled(false);
+    glEnable(GL_COLOR_MATERIAL);
+
+    glEnable(GL_TEXTURE_2D);
+    // Bind the texture to use
+    glBindTexture(GL_TEXTURE_2D,_currentEnvMap); 
+    switch(_blendFunc)
+    {
+    case 0:
+      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+      glEnable(GL_BLEND);
+      break;
+    case 1:
+      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE) ;
+      glDisable(GL_BLEND);
+      break;
+      //    case 2:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+      //      glEnable(GL_BLEND);
+      //      break;
+      //    case 3:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR); 
+      //      glEnable(GL_BLEND);
+      //      break;
+      //    case 4:
+      //      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) ;
+      //      glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA); 
+      //      glEnable(GL_BLEND);
+      //      break;
+    default:
+      break;
+    }
+
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+  }
+
+  // FIXME
+  //  //_ModelRootNode->setLightingEnabled(true);
+  //  if(_ModelRootNode->style() == DrawingStyle::LINES){
+  //    glPushAttrib(GL_ALL_ATTRIB_BITS);
+  //    //glDisable(GL_COLOR_MATERIAL);
+  //    _ModelRootNode->setStyle(DrawingStyle::FILLED);
+  //    _ModelRootNode->setLightingEnabled(true);
+  //    _ModelRootNode->accept(*iRenderer);  
+  //    _ModelRootNode->setStyle(DrawingStyle::LINES);
+  //    _ModelRootNode->setLightingEnabled(false);
+  //    _ModelRootNode->accept(*iRenderer);  
+  //    glPopAttrib();
+  //  }
+  //  else
+  _ModelRootNode->accept(*iRenderer);
+
+  glDisable(GL_TEXTURE_GEN_S);
+  glDisable(GL_TEXTURE_GEN_T);
+  glDisable(GL_TEXTURE_2D);
+  glDisable(GL_COLOR_MATERIAL);
+  _ModelRootNode->setLightingEnabled(true);
+
+  if(_fedges == true)
+    _SilhouetteRootNode->accept(*iRenderer);
+
+  // FIXME: deprecated
+//   if(_debug == true)
+//     _DebugRootNode->accept(*iRenderer);
+  
+  glPopAttrib();
+}
+
+void AppGLWidget::prepareCanvas()
+{
+  makeCurrent();
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+  // if(_frontBufferFlag){
+  //   if(_backBufferFlag)
+  //     glDrawBuffer(GL_FRONT_AND_BACK);
+  //   else
+  //     glDrawBuffer(GL_FRONT);
+  // }
+  // else if(_backBufferFlag)
+  //   glDrawBuffer(GL_BACK);
+	//glDrawBuffer( workingBuffer ); //soc
+
+  // Projection Matrix
+  //==================
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  
+  glOrtho(0,width(), 0, height(), -1.0, 1.0);
+  
+  //Modelview Matrix
+  //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+}
+
+void AppGLWidget::releaseCanvas()
+{
+  makeCurrent();
+  //glDrawBuffer( workingBuffer ); //soc
+  glPopAttrib();
+}
+
+void AppGLWidget::Draw2DScene(SceneVisitor *iRenderer)
+{
+  static bool first = 1;
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+
+//    // Projection Matrix
+//    //==================
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glOrtho(0,width(), 0, height(), -1.0, 1.0);
+
+//    //Modelview Matrix
+//    //================
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  //  glBegin(GL_LINE_LOOP);
+  //  glVertex2f(0,0);
+  //  glVertex2f(100,0);
+  //  glVertex2f(100,100);
+  //  glVertex2f(0,100);
+  //  glEnd();
+
+  //glDrawBuffer(GL_FRONT_AND_BACK);
+  // Draw visible silhouette
+  //_pVisibleSilhouetteNode->Render(iRenderer);
+  Canvas * canvas = Canvas::getInstance();
+  if((canvas) && (!canvas->isEmpty()))
+  {
+    if (first)
+    {
+      canvas->init();
+      first = false;
+    }
+    canvas->Render(canvas->renderer());
+  }
+  
+  glLoadIdentity();
+  //  glColor3f(0.f,1.f,0.f);
+  //  glLineWidth(5.f);
+  //glPolygonOffset(0.5f, 0.5f);
+  glPushAttrib(GL_DEPTH_BUFFER_BIT);
+  glDisable(GL_DEPTH_TEST);
+  _p2DSelectionNode->accept(*iRenderer);
+  glPopAttrib();
+  // Draw Feature edges
+  //  if(_fedges == true)
+  //  {
+  //    _pFENode->Render(iRenderer);
+  //  }
+ 
+  glPopAttrib();
+}
+
+void AppGLWidget::DrawSilhouette()
+{
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+  
+  glDepthFunc(GL_LESS);
+  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+  DrawScene(_pMonoColorRenderer);
+
+  glCullFace(GL_FRONT);
+  glDepthFunc(GL_LEQUAL);
+  glEnable(GL_POLYGON_OFFSET_FILL);
+  glLineWidth(3.0);
+  //glPolygonOffset(10.f, 10.f);
+  glPolygonOffset(0.5f, 0.5f);
+ 
+  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+  _pMonoColorRenderer->setColor(0.f, 0.f, 0.f);
+  DrawScene(_pMonoColorRenderer);
+
+  //Restore old context
+  glPopAttrib();
+
+}
+
+void AppGLWidget::ReInitRenderers()
+{
+  // Debug Renderer
+  if(NULL != _pDebugRenderer)
+    _pDebugRenderer->ReInit(rabs(_ModelRootNode->bbox().getMax()[1] -
+				 _ModelRootNode->bbox().getMin()[1]));
+}
+
+void AppGLWidget::setFrontBufferFlag(bool iBool){
+  _frontBufferFlag = iBool;
+}
+bool AppGLWidget::getFrontBufferFlag() {
+  return _frontBufferFlag;
+}
+void AppGLWidget::setBackBufferFlag(bool iBool){
+  _backBufferFlag = iBool;
+}
+bool AppGLWidget::getBackBufferFlag() {
+  return _backBufferFlag;
+}
+
+//void AppGLWidget::DrawLines()
+//{
+//  //Antialiasing:
+//  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+//  glEnable(GL_BLEND);
+//  glEnable(GL_LINE_SMOOTH);
+//  glPolygonMode(GL_FRONT, GL_LINE);
+//
+//  glColor3f(0.f, 0.f, 0.f);
+//  glLineWidth(2.f);
+//
+//  DrawScene();
+//}
+//
+//void AppGLWidget::DrawSurfacic()
+//{
+//  glPolygonMode(GL_FRONT, GL_FILL);
+//  glShadeModel(GL_SMOOTH);
+//  
+//  glEnable(GL_LIGHTING);
+//  glEnable(GL_LIGHT0);
+//
+//  
+//  GLreal diffuseV[] = {0.5, 0.7, 0.5, 1.0};
+//  glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseV);
+//
+//  //glColor3f(0.f, 0.f, 0.f);
+//
+//  DrawScene();
+//
+//  glDisable(GL_LIGHTING);
+//}
+//
+//void AppGLWidget::DrawDepthBuffer()
+//{
+//  GLint w = width();
+//  GLint h = height();
+//
+//  glPolygonMode(GL_FRONT, GL_FILL);
+//  
+//  //Disable the writing in the frame buffer
+//  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+//
+//  //This rendering will only fills the depth buffer
+//  DrawScene();
+//
+//  //Re-enable the frame buffer writing
+//  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+//
+//
+//  GLreal *zPixels = new real[w*h];
+//  GLreal *colorPixels = new real[4*w*h];
+//
+// // glReadBuffer(GL_FRONT); //in reality: glReadBuffer and glDrawBuffer are both set to GL_BACK
+//  glReadPixels(0,0,w, h, GL_DEPTH_COMPONENT, GL_real, (GLreal*)zPixels);
+//
+//  real *tmpZ = zPixels;
+//  real *tmpColor = colorPixels;
+//
+//  for(int i=0; i<h; i++)
+//  {
+//    for(int j=0; j<w; j++)
+//    {
+//      //fprintf(test, " %.5f ", pixels[i*w+j]);
+//      tmpColor[0] = *tmpZ;
+//      tmpColor[1] = *tmpZ;
+//      tmpColor[2] = *tmpZ;
+//      tmpColor[3] = 1.f;
+//
+//      tmpColor += 4;
+//      tmpZ++;
+//    }
+//  }
+//  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+// // glDrawBuffer(GL_FRONT_AND_BACK);
+//  //glRasterPos2i(0, 0);
+//  //glLoadIdentity();
+//  glDrawPixels(w, h, GL_RGBA, GL_real, (GLreal *)colorPixels);
+//    
+//  delete [] zPixels;
+//  delete [] colorPixels;  
+//}
+
+
+//*******************************
+// COPIED FROM LIBQGLVIEWER
+//*******************************
+
+	// inherited 	
+	//Updates the display. Do not call draw() directly, use this method instead. 
+	void AppGLWidget::updateGL() {}
+
+	//Makes this widget's rendering context the current OpenGL rendering context. Useful with several viewers
+	void AppGLWidget::makeCurrent() { }
+
+	// not-inherited
+	 void AppGLWidget::setStateFileName(const string& name) { stateFileName_ = name; };
+	void AppGLWidget::saveSnapshot(bool b) {}
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget.h b/source/blender/freestyle/intern/app_blender/AppGLWidget.h
new file mode 100755
index 00000000000..97e7cbcebbe
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget.h
@@ -0,0 +1,549 @@
+//
+//  Filename         : AppConfig.h
+//  Author           : Stephane Grabli
+//  Purpose          : Configuration file
+//  Date of creation : 26/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ARTGLWIDGET_H
+# define ARTGLWIDGET_H
+
+# ifndef WIN32
+#  include <algorithm>
+using namespace std;
+#  define __min(x,y) (min(x,y))
+#  define __max(x,y) (max(x,y))
+# endif // WIN32
+
+
+//# include <qstringlist.h>
+# include "../geometry/Geom.h"
+# include "../geometry/BBox.h"
+# include "../scene_graph/NodeDrawingStyle.h"
+# include "../system/TimeUtils.h"
+# include "../system/Precision.h"
+# include "AppConfig.h"
+# include "../rendering/GLDebugRenderer.h"
+//# include <QGLViewer/qglviewer.h>
+
+
+//soc
+#include "AppGLWidget_camera.h"
+#include "AppGLWidget_vec.h"
+#include "AppGLWidget_quaternion.h"
+
+using namespace Geometry;
+
+typedef enum {SURFACIC, LINE, DEPTHBUFFER} RenderStyle;
+
+class FEdge;
+class QMainWindow;
+class GLRenderer;
+class GLSelectRenderer;
+class GLBBoxRenderer;
+class GLMonoColorRenderer;
+class GLDebugRenderer;
+ 
+class AppGLWidget
+{
+
+    
+public:
+
+  AppGLWidget(const char *iName = 0);
+  virtual ~AppGLWidget();
+  
+public:
+
+	//inherited
+		inline unsigned int width() { return _width; }
+		inline unsigned int height() { return _height; }
+		inline void setWidth( unsigned int width ) { _width = width; }
+		inline void setHeight( unsigned int height ) { _height = height; }
+		
+		void updateGL();
+		void makeCurrent();
+	
+	// not-inherited
+		void saveSnapshot(bool b);
+		void setStateFileName(const string& name);
+	
+
+		AppGLWidget_Camera * _camera;
+		int workingBuffer;
+
+protected:
+	unsigned int _width, _height;
+	Vec _min,_max;
+	string stateFileName_;
+
+public:
+
+  // captures a frame animation that was previously registered
+  void captureMovie();
+
+  /*! Sets the rendering style.
+        iStyle
+          The style used to render. Can be:
+          SURFACIC    : usual rendering
+          LINES       : line rendering
+          DEPTHBUFFER : grey-levels rendering of the depth buffer
+          */
+  inline void setRenderStyle(RenderStyle iStyle)
+  {
+    _RenderStyle = iStyle;
+  }
+
+  /*! Sets the model to draw in the viewer 
+   *  iModel
+   *    The Root Node of the model 
+   */
+  inline void setModel(NodeGroup *iModel)
+  {
+    if(0 != _ModelRootNode->numberOfChildren())
+    {
+      _ModelRootNode->DetachChildren();
+      _ModelRootNode->clearBBox();
+    }
+      
+    AddModel(iModel);
+  }
+
+  /*! Adds a model for displaying in the viewer */
+  inline void AddModel(NodeGroup *iModel) 
+  {
+    _ModelRootNode->AddChild(iModel);
+    
+    _ModelRootNode->UpdateBBox();
+
+    _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+    
+     _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+
+     _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+
+     // DEBUG:
+    ReInitRenderers();
+ 
+  }
+
+  inline void AddSilhouette(NodeGroup* iSilhouette)
+  {
+    _SilhouetteRootNode->AddChild(iSilhouette);
+    //ToggleSilhouette(true);
+    updateGL();
+  }
+
+  inline void Add2DSilhouette(NodeGroup *iSilhouette)
+  {
+    //_pFENode->AddChild(iSilhouette);
+    //ToggleSilhouette(true);
+    updateGL();
+  }
+
+  inline void Add2DVisibleSilhouette(NodeGroup *iVSilhouette)
+  {
+    //_pVisibleSilhouetteNode->AddChild(iVSilhouette);
+    updateGL();
+  }
+
+  inline void setDebug(NodeGroup* iDebug)
+  {
+    if(0 != _DebugRootNode->numberOfChildren())
+    {
+      _DebugRootNode->DetachChildren();
+      _DebugRootNode->clearBBox();
+    }
+      
+    AddDebug(iDebug);
+  }
+
+  inline void AddDebug(NodeGroup* iDebug)
+  {
+    _DebugRootNode->AddChild(iDebug);
+    updateGL();
+  }
+
+  inline void DetachModel(Node *iModel)
+  {
+    _ModelRootNode->DetachChild(iModel);
+    _ModelRootNode->UpdateBBox();
+    
+    _minBBox = __min(__min(_ModelRootNode->bbox().getMin()[0], 
+                            _ModelRootNode->bbox().getMin()[1]),
+                      _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = __max(__max(_ModelRootNode->bbox().getMax()[0], 
+                            _ModelRootNode->bbox().getMax()[1]),
+                      _ModelRootNode->bbox().getMax()[2]);
+    
+     _maxAbs = __max(rabs(_minBBox), rabs(_maxBBox));
+     _minAbs = __min(rabs(_minBBox), rabs(_maxBBox));
+  } 
+
+  inline void DetachModel() 
+  {
+    _ModelRootNode->DetachChildren();
+    _ModelRootNode->clearBBox();
+    
+    // 2D Scene
+    //_p2DNode.DetachChildren();
+    //_pFENode->DetachChildren();
+    //_pVisibleSilhouetteNode->DetachChildren();
+    updateGL();
+  }
+
+  inline void DetachSilhouette()
+  {
+    _SilhouetteRootNode->DetachChildren();
+    //_pFENode->DetachChildren();
+    //_pVisibleSilhouetteNode->DetachChildren();
+    _p2DSelectionNode->destroy();
+    //updateGL(); //FIXME
+  }
+
+  inline void DetachVisibleSilhouette()
+  {
+    //_pVisibleSilhouetteNode->DetachChildren();
+    _p2DSelectionNode->destroy();
+    updateGL();
+  }
+
+  inline void DetachDebug()
+  {
+    _DebugRootNode->DetachChildren();
+    updateGL();
+  }
+
+  void setMainWindow(QMainWindow *iMainWindow) ;
+
+  inline void set3DContext()
+  {
+    // GL_PROJECTION matrix
+    _camera->loadProjectionMatrix();
+    // GL_MODELVIEW matrix
+    _camera->loadModelViewMatrix();
+  }
+  
+  inline void RetriveModelViewMatrix(float *p)
+  {
+    makeCurrent();
+    glGetFloatv(GL_MODELVIEW_MATRIX, p);
+  }
+  inline void RetriveModelViewMatrix(real *p)
+  {
+    makeCurrent();
+    glGetDoublev(GL_MODELVIEW_MATRIX, p);
+  }
+
+  inline void RetrieveProjectionMatrix(float *p)
+  {
+    makeCurrent();
+    glGetFloatv(GL_PROJECTION_MATRIX, p);
+
+  }
+  inline void RetrieveProjectionMatrix(real *p)
+  {
+    makeCurrent();
+    glGetDoublev(GL_PROJECTION_MATRIX, p);
+
+  }
+
+  inline void RetrieveViewport(int *p)
+  {
+    makeCurrent();
+    glGetIntegerv(GL_VIEWPORT,(GLint *)p);
+  }
+  
+  inline real GetFocalLength() const
+  {
+    real Near =  __max(0.1,(real)(-2.f*_maxAbs+_camera->distanceToSceneCenter()));
+    return Near;
+  }
+
+  inline real GetAspect() const
+  {
+    return ((real) _width/(real) _height);
+  }
+
+  inline real GetFovyRadian() const
+  {
+    return _Fovy/180.0 * M_PI;
+  }
+
+  inline real GetFovyDegrees() const
+  {
+    return _Fovy;
+  }
+
+  inline void FitBBox()
+  {
+	Vec min_(_ModelRootNode->bbox().getMin()[0],
+    			_ModelRootNode->bbox().getMin()[1],
+    			_ModelRootNode->bbox().getMin()[2]);
+	Vec max_(_ModelRootNode->bbox().getMax()[0],
+    			_ModelRootNode->bbox().getMax()[1],
+    			_ModelRootNode->bbox().getMax()[2]);
+    _camera->setSceneBoundingBox(min_, max_);
+    _camera->showEntireScene();
+  }
+  
+  inline void ToggleSilhouette(bool enabled) 
+  {
+    _fedges = enabled;
+    updateGL();
+  }
+  
+  // Reinit the renderers which need to be informed
+  // when a model is added to the scene.
+  void ReInitRenderers();
+
+  inline void setSelectedFEdge(FEdge* iFEdge) { _pDebugRenderer->setSelectedFEdge(iFEdge); }
+
+  inline GLDebugRenderer* debugRenderer() { return _pDebugRenderer; }
+  inline void toggle3D() { _Draw3DScene == true ? _Draw3DScene = false : _Draw3DScene = true; updateGL();}
+
+  /*! glReadPixels */
+  typedef enum{
+	RGBA,
+    RGB,
+    DEPTH
+  } PixelFormat;
+  void readPixels(int x,
+                  int y,
+                  int width,
+                  int height,
+                  PixelFormat format,
+                  float *pixels) 
+  {
+    makeCurrent();
+    //glReadBuffer(GL_FRONT); //in reality: glReadBuffer and glDrawBuffer are both set to GL_BACK
+    //glReadBuffer(GL_BACK);
+    GLenum glformat;
+    switch(format)
+    {
+	    case RGBA:
+	      glformat = GL_RGBA;
+	      break;
+    case RGB:
+      glformat = GL_RGB;
+      break;
+    case DEPTH:
+      glformat = GL_DEPTH_COMPONENT;
+      break;
+    default:
+      break;
+    }
+    glReadPixels(x,y,width, height, glformat, GL_FLOAT, (GLfloat*)pixels);
+  }
+
+  void clear() { makeCurrent(); glClear(GL_COLOR_BUFFER_BIT ); }
+
+  void prepareCanvas();
+  void releaseCanvas();
+
+  typedef enum {
+    FRONT,
+    BACK
+  } GLBuffer;
+
+  // void setReadPixelsBuffer(int iBuffer) 
+  // {
+  //   makeCurrent();
+  //   switch(iBuffer)
+  //   {
+  //   case FRONT:
+  //     glReadBuffer(GL_FRONT);
+  //     break;
+  //   case BACK:
+  //     glReadBuffer(GL_BACK);
+  //     break;
+  //   default:
+  //     break;
+  //   }
+  // }
+
+  BBox<Vec3r> scene3DBBox() const { return _ModelRootNode->bbox(); }
+
+  inline real znear() const {
+    return _camera->zNear();
+  }
+  
+  inline real zfar() const {
+    return _camera->zFar();
+  }
+
+  inline bool draw3DsceneEnabled() const { return _Draw3DScene; }
+
+  inline bool getRecordFlag() const {return _record;}
+
+  void setCameraState(const Vec& position, const Quaternion& orientation) {
+    _camera->setPosition(position);
+    _camera->setOrientation(orientation);
+  }
+
+  void getCameraState(float* position, float* orientation) const {
+	Vec pos = _camera->position();
+	Quaternion orient = _camera->orientation();
+    int i;
+    for(i=0;i<3;++i){
+      position[i] = pos[i];
+    }
+    for(i=0;i<4;++i){
+      orientation[i] = orient[i];
+    }
+  }
+
+  void saveCameraState() {
+    getCameraState(_cameraPosition, _cameraOrientation);
+    _cameraStateSaved = true;
+  }
+
+  void setUpdateMode(bool b) {
+    _enableUpdateSilhouettes = b;
+  }
+
+  bool getUpdateMode() const {
+    return _enableUpdateSilhouettes;
+  }
+  static void setFrontBufferFlag(bool iBool);
+  static bool getFrontBufferFlag();
+  static void setBackBufferFlag(bool iBool);
+  static bool getBackBufferFlag();
+
+public:
+  virtual void    draw();
+
+protected:
+  virtual void	  init();
+
+  /*! Loads an envmap */
+  void LoadEnvMap(const char *filename);
+
+public:
+  /*! Core scene drawing */
+  void            DrawScene(SceneVisitor *iRenderer);
+
+  /*! 2D Scene Drawing */
+  void            Draw2DScene(SceneVisitor *iRenderer);
+
+  /*! Draws scene silhouettes in real time */
+  void            DrawSilhouette();
+  
+  /*! Draws the Scene in lines style */
+  //  void            DrawLines();
+  //  /*! Draws the scene in surfacic style */
+  //  void            DrawSurfacic();
+  //  /*! Draws the scene as a depth buffer image */
+  //  void            DrawDepthBuffer();
+
+  GLRenderer* glRenderer() {return _pGLRenderer;}
+
+protected:
+
+
+  //QString shortcutBindingsString() const;
+
+  /*! fabs or abs */
+  inline int rabs(int x) {return abs(x);}
+  inline real rabs(real x) {return fabs(x);}
+
+  
+protected:
+  float _Fovy;
+  //float _SceneDepth;
+  //BBox<Vec3f> _BBox;
+  
+  RenderStyle _RenderStyle;
+
+  //The root node container
+  NodeGroup        _RootNode;
+  NodeDrawingStyle *_ModelRootNode;
+  NodeDrawingStyle *_SilhouetteRootNode;
+  NodeDrawingStyle *_DebugRootNode;
+  
+  bool _silhouette;
+  bool _fedges;
+  bool _debug;
+  bool _selection_mode;
+
+  //a Universal light:
+  NodeGroup _Light;
+
+  real _minBBox;
+  real _maxBBox;
+  real _maxAbs;
+
+  real _minAbs;
+  bool _drawBBox;
+
+  // OpenGL Renderer
+  GLRenderer *_pGLRenderer;
+  GLSelectRenderer *_pSelectRenderer;
+  GLBBoxRenderer *_pBBoxRenderer;
+  GLMonoColorRenderer *_pMonoColorRenderer;
+  GLDebugRenderer *_pDebugRenderer;
+  
+  QMainWindow *_pMainWindow;
+
+  Chronometer _Chrono;
+
+  // 2D Scene
+  bool _Draw2DScene;
+  bool _Draw3DScene;  NodeGroup _p2DNode;
+  //NodeDrawingStyle *_pFENode; // Feature edges node
+  //NodeDrawingStyle *_pVisibleSilhouetteNode;
+  NodeDrawingStyle *_p2DSelectionNode;
+
+  // EnvMap
+  bool _drawEnvMap;
+  int _currentEnvMap;
+  int _maxId;
+  int _blendFunc;
+
+  // Each time we compute the view map, the camera state is 
+  // saved in order to be able to restore it later
+  bool  _cameraStateSaved;
+  float _cameraPosition[3];
+  float _cameraOrientation[4];
+
+  // interactive silhouette update
+  bool _enableUpdateSilhouettes;
+  //capture movie
+  bool _captureMovie;
+  // 2D drawing buffers
+  static bool _frontBufferFlag;
+  static bool _backBufferFlag;
+
+  bool _record;
+
+
+
+};
+
+#endif // ARTGLWIDGET_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.cpp
new file mode 100644
index 00000000000..26f2e024cd8
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.cpp
@@ -0,0 +1,1799 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_camera.h"
+//#include "qglviewer.h"
+
+using namespace std;
+//using namespace qglviewer;
+
+/*! Default constructor.
+
+ sceneCenter() is set to (0,0,0) and sceneRadius() is set to 1.0. type() is Camera::PERSPECTIVE,
+ with a \c M_PI/4 fieldOfView().
+
+ See IODistance(), physicalDistanceToScreen(), physicalScreenWidth() and focusDistance()
+ documentations for default stereo parameter values. */
+AppGLWidget_Camera::AppGLWidget_Camera()
+  : fieldOfView_(M_PI/4.0f)
+{
+  // #CONNECTION# Camera copy constructor
+  //interpolationKfi_ = new KeyFrameInterpolator;
+  // Requires the interpolationKfi_
+  setFrame(new ManipulatedCameraFrame());
+
+  // #CONNECTION# All these default values identical in initFromDOMElement.
+
+  // Requires fieldOfView() to define focusDistance()
+  setSceneRadius(1.0);
+
+  // Initial value (only scaled after this)
+  orthoCoef_ = tan(fieldOfView()/2.0);
+
+  // Also defines the revolveAroundPoint(), which changes orthoCoef_. Requires a frame().
+  setSceneCenter(Vec(0.0, 0.0, 0.0));
+
+  // Requires fieldOfView() when called with ORTHOGRAPHIC. Attention to projectionMatrix_ below.
+  setType(PERSPECTIVE);
+
+  // #CONNECTION# initFromDOMElement default values
+  setZNearCoefficient(0.005f);
+  setZClippingCoefficient(sqrt(3.0));
+
+  // Dummy values
+  setScreenWidthAndHeight(600, 400);
+
+  // Stereo parameters
+  setIODistance(0.062f);
+  setPhysicalDistanceToScreen(0.5f);
+  setPhysicalScreenWidth(0.4f);
+  // focusDistance is set from setFieldOfView()
+
+  // #CONNECTION# Camera copy constructor
+  for (unsigned short j=0; j<16; ++j)
+    {
+      modelViewMatrix_[j] = ((j%5 == 0) ? 1.0 : 0.0);
+      // #CONNECTION# computeProjectionMatrix() is lazy and assumes 0.0 almost everywhere.
+      projectionMatrix_[j] = 0.0;
+    }
+  computeProjectionMatrix();
+}
+
+/*! Virtual destructor.
+
+ The frame() is deleted, but the different keyFrameInterpolator() are \e not deleted (in case they
+ are shared). */
+AppGLWidget_Camera::~AppGLWidget_Camera()
+{
+  delete frame_;
+  //delete interpolationKfi_;
+}
+
+
+/*! Copy constructor. Performs a deep copy using operator=(). */
+AppGLWidget_Camera::AppGLWidget_Camera(const AppGLWidget_Camera& camera)
+{
+  // #CONNECTION# Camera constructor
+  //interpolationKfi_ = new KeyFrameInterpolator;
+  // Requires the interpolationKfi_
+  setFrame(new ManipulatedCameraFrame());
+
+  for (unsigned short j=0; j<16; ++j)
+    {
+      modelViewMatrix_[j] = ((j%5 == 0) ? 1.0 : 0.0);
+      // #CONNECTION# computeProjectionMatrix() is lazy and assumes 0.0 almost everywhere.
+      projectionMatrix_[j] = 0.0;
+    }
+
+  (*this)=camera;
+}
+
+/*! Equal operator.
+
+ All the parameters of \p camera are copied. The frame() pointer is not modified, but its
+ Frame::position() and Frame::orientation() are set to those of \p camera.
+
+ \attention The Camera screenWidth() and screenHeight() are set to those of \p camera. If your
+ Camera is associated with a QGLViewer, you should update these value after the call to this method:
+ \code
+ *(camera()) = otherCamera;
+ camera()->setScreenWidthAndHeight(width(), height());
+ \endcode
+ The same applies to sceneCenter() and sceneRadius(), if needed. */
+AppGLWidget_Camera& AppGLWidget_Camera::operator=(const AppGLWidget_Camera& camera)
+{
+  setScreenWidthAndHeight(camera.screenWidth(), camera.screenHeight());
+  setFieldOfView(camera.fieldOfView());
+  setSceneRadius(camera.sceneRadius());
+  setSceneCenter(camera.sceneCenter());
+  setZNearCoefficient(camera.zNearCoefficient());
+  setZClippingCoefficient(camera.zClippingCoefficient());
+  setType(camera.type());
+
+  // Stereo parameters
+  setIODistance(camera.IODistance());
+  setFocusDistance(camera.focusDistance());
+  setPhysicalScreenWidth(camera.physicalScreenWidth());
+  setPhysicalDistanceToScreen(camera.physicalDistanceToScreen());
+
+  orthoCoef_ = camera.orthoCoef_;
+
+  // frame_ and interpolationKfi_ pointers are not shared.
+  frame_->setReferenceFrame(NULL);
+  frame_->setPosition(camera.position());
+  frame_->setOrientation(camera.orientation());
+
+  //interpolationKfi_->resetInterpolation();
+
+  //kfi_ = camera.kfi_;
+
+  computeProjectionMatrix();
+  computeModelViewMatrix();
+
+  return *this;
+}
+
+/*! Sets Camera screenWidth() and screenHeight() (expressed in pixels).
+
+You should not call this method when the Camera is associated with a QGLViewer, since the
+latter automatically updates these values when it is resized (hence overwritting your values).
+
+Non-positive dimension are silently replaced by a 1 pixel value to ensure frustrum coherence.
+
+If your Camera is used without a QGLViewer (offscreen rendering, shadow maps), use setAspectRatio()
+instead to define the projection matrix. */
+void AppGLWidget_Camera::setScreenWidthAndHeight(int width, int height)
+{
+  // Prevent negative and zero dimensions that would cause divisions by zero.
+	screenWidth_  = width > 0 ? width : 1;
+	screenHeight_ = height > 0 ? height : 1;
+}
+
+/*! Returns the near clipping plane distance used by the Camera projection matrix.
+
+ The clipping planes' positions depend on the sceneRadius() and sceneCenter() rather than being fixed
+ small-enough and large-enough values. A good scene dimension approximation will hence result in an
+ optimal precision of the z-buffer.
+
+ The near clipping plane is positioned at a distance equal to zClippingCoefficient() * sceneRadius()
+ in front of the sceneCenter():
+ \code
+ zNear = distanceToSceneCenter() - zClippingCoefficient()*sceneRadius();
+ \endcode
+
+ In order to prevent negative or too small zNear() values (which would degrade the z precision),
+ zNearCoefficient() is used when the Camera is inside the sceneRadius() sphere:
+ \code
+ const float zMin = zNearCoefficient() * zClippingCoefficient() * sceneRadius();
+ if (zNear < zMin)
+   zNear = zMin;
+ // With an ORTHOGRAPHIC type, the value is simply clamped to 0.0
+ \endcode
+
+ See also the zFar(), zClippingCoefficient() and zNearCoefficient() documentations.
+
+ If you need a completely different zNear computation, overload the zNear() and zFar() methods in a
+ new class that publicly inherits from Camera and use QGLViewer::setCamera():
+ \code
+ class myCamera :: public qglviewer::Camera
+ {
+   virtual float Camera::zNear() const { return 0.001; };
+   virtual float Camera::zFar() const { return 100.0; };
+ }
+ \endcode
+
+ See the <a href="../examples/standardCamera.html">standardCamera example</a> for an application.
+
+ \attention The value is always positive although the clipping plane is positioned at a negative z
+ value in the Camera coordinate system. This follows the \c gluPerspective standard. */
+float AppGLWidget_Camera::zNear() const
+{
+  float z = distanceToSceneCenter() - zClippingCoefficient()*sceneRadius();
+
+  // Prevents negative or null zNear values.
+  const float zMin = zNearCoefficient() * zClippingCoefficient() * sceneRadius();
+  if (z < zMin)
+    switch (type())
+      {
+      case AppGLWidget_Camera::PERSPECTIVE  : z = zMin; break;
+      case AppGLWidget_Camera::ORTHOGRAPHIC : z = 0.0;  break;
+      }
+  return z;
+}
+
+/*! Returns the far clipping plane distance used by the Camera projection matrix.
+
+The far clipping plane is positioned at a distance equal to zClippingCoefficient() * sceneRadius()
+behind the sceneCenter():
+\code
+zFar = distanceToSceneCenter() + zClippingCoefficient()*sceneRadius();
+\endcode
+
+See the zNear() documentation for details. */
+float AppGLWidget_Camera::zFar() const
+{
+  return distanceToSceneCenter() + zClippingCoefficient()*sceneRadius();
+}
+
+/*! Defines the Camera type().
+
+Prefix the type with Camera, as in: \code camera()->setType(Camera::ORTHOGRAPHIC); // or even
+qglviewer::Camera::ORTHOGRAPHIC if you do not use namespace \endcode */
+void AppGLWidget_Camera::setType(Type type)
+{
+  // make ORTHOGRAPHIC frustum fit PERSPECTIVE (at least in plane normal to viewDirection(), passing
+  // through RAP) Done only when CHANGING type since orthoCoef_ may have been changed with a
+  // setRevolveAroundPoint() in the meantime.
+  if ( (type == AppGLWidget_Camera::ORTHOGRAPHIC) && (type_ == AppGLWidget_Camera::PERSPECTIVE) )
+    orthoCoef_ = tan(fieldOfView()/2.0);
+  type_ = type;
+}
+
+/*! Sets the Camera frame().
+
+If you want to move the Camera, use setPosition() and setOrientation() or one of the Camera
+positioning methods (lookAt(), fitSphere(), showEntireScene()...) instead.
+
+If you want to save the Camera position(), there's no need to call this method either. Use
+addKeyFrameToPath() and playPath() instead.
+
+This method is actually mainly useful if you derive the ManipulatedCameraFrame class and want to
+use an instance of your new class to move the Camera.
+
+A \c NULL \p mcf pointer will silently be ignored. The calling method is responsible for
+deleting the previous frame() pointer if needed in order to prevent memory leaks. */
+void AppGLWidget_Camera::setFrame(ManipulatedCameraFrame* const mcf)
+{
+  if (!mcf)
+    return;
+
+  frame_ = mcf;
+  //interpolationKfi_->setFrame(frame());
+}
+
+/*! Returns the distance from the Camera center to sceneCenter(), projected along the Camera Z axis.
+  Used by zNear() and zFar() to optimize the Z range. */
+float AppGLWidget_Camera::distanceToSceneCenter() const
+{
+  return fabs((frame()->coordinatesOf(sceneCenter())).z);
+}
+
+
+/*! Returns the \p halfWidth and \p halfHeight of the Camera orthographic frustum.
+
+ These values are only valid and used when the Camera is of type() Camera::ORTHOGRAPHIC. They are
+ expressed in OpenGL units and are used by loadProjectionMatrix() to define the projection matrix
+ using:
+ \code
+ glOrtho( -halfWidth, halfWidth, -halfHeight, halfHeight, zNear(), zFar() )
+ \endcode
+
+ These values are proportional to the Camera (z projected) distance to the revolveAroundPoint().
+ When zooming on the object, the Camera is translated forward \e and its frustum is narrowed, making
+ the object appear bigger on screen, as intuitively expected.
+
+ Overload this method to change this behavior if desired, as is done in the 
+ <a href="../examples/standardCamera.html">standardCamera example</a>. */
+void AppGLWidget_Camera::getOrthoWidthHeight(GLdouble& halfWidth, GLdouble& halfHeight) const
+{
+  const float dist = orthoCoef_ * fabs(cameraCoordinatesOf(revolveAroundPoint()).z);
+  //#CONNECTION# fitScreenRegion
+  halfWidth  = dist * ((aspectRatio() < 1.0) ? 1.0 : aspectRatio());
+  halfHeight = dist * ((aspectRatio() < 1.0) ? 1.0/aspectRatio() : 1.0);
+}
+
+
+/*! Computes the projection matrix associated with the Camera.
+
+ If type() is Camera::PERSPECTIVE, defines a \c GL_PROJECTION matrix similar to what would \c
+ gluPerspective() do using the fieldOfView(), window aspectRatio(), zNear() and zFar() parameters.
+
+ If type() is Camera::ORTHOGRAPHIC, the projection matrix is as what \c glOrtho() would do.
+ Frustum's width and height are set using getOrthoWidthHeight().
+
+ Both types use zNear() and zFar() to place clipping planes. These values are determined from
+ sceneRadius() and sceneCenter() so that they best fit the scene size.
+
+ Use getProjectionMatrix() to retrieve this matrix. Overload loadProjectionMatrix() if you want your
+ Camera to use an exotic projection matrix.
+
+ \note You must call this method if your Camera is not associated with a QGLViewer and is used for
+ offscreen computations (using (un)projectedCoordinatesOf() for instance). loadProjectionMatrix()
+ does it otherwise. */
+void AppGLWidget_Camera::computeProjectionMatrix() const
+{
+  const float ZNear = zNear();
+  const float ZFar  = zFar();
+
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE:
+      {
+	// #CONNECTION# all non null coefficients were set to 0.0 in constructor.
+	const float f = 1.0/tan(fieldOfView()/2.0);
+	projectionMatrix_[0]  = f/aspectRatio();
+	projectionMatrix_[5]  = f;
+	projectionMatrix_[10] = (ZNear + ZFar) / (ZNear - ZFar);
+	projectionMatrix_[11] = -1.0;
+	projectionMatrix_[14] = 2.0 * ZNear * ZFar / (ZNear - ZFar);
+	projectionMatrix_[15] = 0.0;
+	// same as gluPerspective( 180.0*fieldOfView()/M_PI, aspectRatio(), zNear(), zFar() );
+	break;
+      }
+    case AppGLWidget_Camera::ORTHOGRAPHIC:
+      {
+	GLdouble w, h;
+	getOrthoWidthHeight(w,h);
+	projectionMatrix_[0]  = 1.0/w;
+	projectionMatrix_[5]  = 1.0/h;
+	projectionMatrix_[10] = -2.0/(ZFar - ZNear);
+	projectionMatrix_[11] = 0.0;
+	projectionMatrix_[14] = -(ZFar + ZNear)/(ZFar - ZNear);
+	projectionMatrix_[15] = 1.0;
+	// same as glOrtho( -w, w, -h, h, zNear(), zFar() );
+	break;
+      }
+    }
+}
+
+/*! Computes the modelView matrix associated with the Camera's position() and orientation().
+
+ This matrix converts from the world coordinates system to the Camera coordinates system, so that
+ coordinates can then be projected on screen using the projection matrix (see computeProjectionMatrix()).
+
+ Use getModelViewMatrix() to retrieve this matrix.
+
+ \note You must call this method if your Camera is not associated with a QGLViewer and is used for
+ offscreen computations (using (un)projectedCoordinatesOf() for instance). loadModelViewMatrix()
+ does it otherwise. */
+void AppGLWidget_Camera::computeModelViewMatrix() const
+{
+  const Quaternion q = frame()->orientation();
+
+  const double q00 = 2.0l * q[0] * q[0];
+  const double q11 = 2.0l * q[1] * q[1];
+  const double q22 = 2.0l * q[2] * q[2];
+
+  const double q01 = 2.0l * q[0] * q[1];
+  const double q02 = 2.0l * q[0] * q[2];
+  const double q03 = 2.0l * q[0] * q[3];
+
+  const double q12 = 2.0l * q[1] * q[2];
+  const double q13 = 2.0l * q[1] * q[3];
+
+  const double q23 = 2.0l * q[2] * q[3];
+
+  modelViewMatrix_[0] = 1.0l - q11 - q22;
+  modelViewMatrix_[1] =        q01 - q23;
+  modelViewMatrix_[2] =        q02 + q13;
+  modelViewMatrix_[3] = 0.0l;
+
+  modelViewMatrix_[4] =        q01 + q23;
+  modelViewMatrix_[5] = 1.0l - q22 - q00;
+  modelViewMatrix_[6] =        q12 - q03;
+  modelViewMatrix_[7] = 0.0l;
+
+  modelViewMatrix_[8] =        q02 - q13;
+  modelViewMatrix_[9] =        q12 + q03;
+  modelViewMatrix_[10] = 1.0l - q11 - q00;
+  modelViewMatrix_[11] = 0.0l;
+
+  const Vec t = q.inverseRotate(frame()->position());
+
+  modelViewMatrix_[12] = -t.x;
+  modelViewMatrix_[13] = -t.y;
+  modelViewMatrix_[14] = -t.z;
+  modelViewMatrix_[15] = 1.0l;
+}
+
+
+/*! Loads the OpenGL \c GL_PROJECTION matrix with the Camera projection matrix.
+
+ The Camera projection matrix is computed using computeProjectionMatrix().
+
+ When \p reset is \c true (default), the method clears the previous projection matrix by calling \c
+ glLoadIdentity before setting the matrix. Setting \p reset to \c false is useful for \c GL_SELECT
+ mode, to combine the pushed matrix with a picking matrix. See QGLViewer::beginSelection() for details.
+
+ This method is used by QGLViewer::preDraw() (called before user's QGLViewer::draw() method) to
+ set the \c GL_PROJECTION matrix according to the viewer's QGLViewer::camera() settings.
+
+ Use getProjectionMatrix() to retrieve this matrix. Overload this method if you want your Camera to
+ use an exotic projection matrix. See also loadModelViewMatrix().
+
+ \attention \c glMatrixMode is set to \c GL_PROJECTION.
+
+ \attention If you use several OpenGL contexts and bypass the Qt main refresh loop, you should call
+ QGLWidget::makeCurrent() before this method in order to activate the right OpenGL context. */
+void AppGLWidget_Camera::loadProjectionMatrix(bool reset) const
+{
+  // WARNING: makeCurrent must be called by every calling method
+  glMatrixMode(GL_PROJECTION);
+
+  if (reset)
+    glLoadIdentity();
+
+  computeProjectionMatrix();
+
+  glMultMatrixd(projectionMatrix_);
+}
+
+/*! Loads the OpenGL \c GL_MODELVIEW matrix with the modelView matrix corresponding to the Camera.
+
+ Calls computeModelViewMatrix() to compute the Camera's modelView matrix.
+
+ This method is used by QGLViewer::preDraw() (called before user's QGLViewer::draw() method) to
+ set the \c GL_MODELVIEW matrix according to the viewer's QGLViewer::camera() position() and
+ orientation().
+
+ As a result, the vertices used in QGLViewer::draw() can be defined in the so called world
+ coordinate system. They are multiplied by this matrix to get converted to the Camera coordinate
+ system, before getting projected using the \c GL_PROJECTION matrix (see loadProjectionMatrix()).
+
+ When \p reset is \c true (default), the method loads (overwrites) the \c GL_MODELVIEW matrix. Setting
+ \p reset to \c false simply calls \c glMultMatrixd (might be useful for some applications).
+
+ Overload this method or simply call glLoadMatrixd() at the beginning of QGLViewer::draw() if you
+ want your Camera to use an exotic modelView matrix. See also loadProjectionMatrix().
+
+ getModelViewMatrix() returns the 4x4 modelView matrix.
+
+ \attention glMatrixMode is set to \c GL_MODELVIEW
+
+ \attention If you use several OpenGL contexts and bypass the Qt main refresh loop, you should call
+ QGLWidget::makeCurrent() before this method in order to activate the right OpenGL context. */
+void AppGLWidget_Camera::loadModelViewMatrix(bool reset) const
+{
+  // WARNING: makeCurrent must be called by every calling method
+  glMatrixMode(GL_MODELVIEW);
+  computeModelViewMatrix();
+  if (reset)
+    glLoadMatrixd(modelViewMatrix_);
+  else
+    glMultMatrixd(modelViewMatrix_);
+}
+
+/*! Same as loadProjectionMatrix() but for a stereo setup.
+
+ Only the Camera::PERSPECTIVE type() is supported for stereo mode. See
+ QGLViewer::setStereoDisplay().
+
+ Uses focusDistance(), IODistance(), and physicalScreenWidth() to compute cameras
+ offset and asymmetric frustums.
+
+ When \p leftBuffer is \c true, computes the projection matrix associated to the left eye (right eye
+ otherwise). See also loadModelViewMatrixStereo().
+
+ See the <a href="../examples/stereoViewer.html">stereoViewer</a> and the <a
+ href="../examples/contribs.html#anaglyph">anaglyph</a> examples for an illustration.
+
+ To retrieve this matrix, use a code like:
+ \code
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ loadProjectionMatrixStereo(left_or_right);
+ glGetFloatv(GL_PROJECTION_MATRIX, m);
+ glPopMatrix();
+ \endcode
+ Note that getProjectionMatrix() always returns the mono-vision matrix.
+
+ \attention glMatrixMode is set to \c GL_PROJECTION. */
+void AppGLWidget_Camera::loadProjectionMatrixStereo(bool leftBuffer) const
+{
+  float left, right, bottom, top;
+  float screenHalfWidth, halfWidth, side, shift, delta;
+
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE:
+      // compute half width of screen,
+      // corresponding to zero parallax plane to deduce decay of cameras
+      screenHalfWidth = focusDistance() * tan(horizontalFieldOfView() / 2.0);
+      shift = screenHalfWidth * IODistance() / physicalScreenWidth();
+      // should be * current y  / y total
+      // to take into account that the window doesn't cover the entire screen
+
+      // compute half width of "view" at znear and the delta corresponding to
+      // the shifted camera to deduce what to set for asymmetric frustums
+      halfWidth = zNear() * tan(horizontalFieldOfView() / 2.0);
+      delta  = shift * zNear() / focusDistance();
+      side   = leftBuffer ? -1.0 : 1.0;
+
+      left   = -halfWidth + side * delta;
+      right  =  halfWidth + side * delta;
+      top    = halfWidth / aspectRatio();
+      bottom = -top;
+      glFrustum(left, right, bottom, top, zNear(), zFar() );
+      break;
+
+    case AppGLWidget_Camera::ORTHOGRAPHIC:
+      cout << "AppGLWidget_Camera::setProjectionMatrixStereo: Stereo not available with Ortho mode";
+      break;
+    }
+}
+
+/*! Same as loadModelViewMatrix() but for a stereo setup.
+
+ Only the Camera::PERSPECTIVE type() is supported for stereo mode. See
+ QGLViewer::setStereoDisplay().
+
+ The modelView matrix is almost identical to the mono-vision one. It is simply translated along its
+ horizontal axis by a value that depends on stereo parameters (see focusDistance(),
+ IODistance(), and physicalScreenWidth()).
+
+ When \p leftBuffer is \c true, computes the modelView matrix associated to the left eye (right eye
+ otherwise).
+
+ loadProjectionMatrixStereo() explains how to retrieve to resulting matrix.
+
+ See the <a href="../examples/stereoViewer.html">stereoViewer</a> and the <a
+ href="../examples/contribs.html#anaglyph">anaglyph</a> examples for an illustration.
+
+ \attention glMatrixMode is set to \c GL_MODELVIEW. */
+void AppGLWidget_Camera::loadModelViewMatrixStereo(bool leftBuffer) const
+{
+  // WARNING: makeCurrent must be called by every calling method
+  glMatrixMode(GL_MODELVIEW);
+
+  float halfWidth = focusDistance() * tan(horizontalFieldOfView() / 2.0);
+  float shift     = halfWidth * IODistance() / physicalScreenWidth(); // * current window width / full screen width
+
+  computeModelViewMatrix();
+  if (leftBuffer)
+    modelViewMatrix_[12] -= shift;
+  else
+    modelViewMatrix_[12] += shift;
+  glLoadMatrixd(modelViewMatrix_);
+}
+
+/*! Fills \p m with the Camera projection matrix values.
+
+ Calls computeProjectionMatrix() to define the Camera projection matrix.
+
+ This matrix only reflects the Camera's internal parameters and it may differ from the \c
+ GL_PROJECTION matrix retrieved using \c glGetDoublev(GL_PROJECTION_MATRIX, m). It actually
+ represents the state of the \c GL_PROJECTION after QGLViewer::preDraw(), at the beginning of
+ QGLViewer::draw(). If you modified the \c GL_PROJECTION matrix (for instance using
+ QGLViewer::startScreenCoordinatesSystem()), the two results differ.
+ 
+ The result is an OpenGL 4x4 matrix, which is given in \e column-major order (see \c glMultMatrix
+ man page for details).
+
+ See also getModelViewMatrix() and setFromProjectionMatrix(). */
+void AppGLWidget_Camera::getProjectionMatrix(GLdouble m[16]) const
+{
+  // May not be needed, but easier and more robust like this.
+  computeProjectionMatrix();
+  for (unsigned short i=0; i<16; ++i)
+    m[i] = projectionMatrix_[i];
+}
+
+/*! Fills \p m with the Camera modelView matrix values.
+
+ First calls computeModelViewMatrix() to define the Camera modelView matrix.
+
+ Note that this matrix is usually \e not the one you would get from a \c
+ glGetDoublev(GL_MODELVIEW_MATRIX, m). It actually represents the state of the \c
+ GL_MODELVIEW after QGLViewer::preDraw(), at the beginning of QGLViewer::draw(). It converts from
+ the world to the Camera coordinate system. As soon as you modify the \c GL_MODELVIEW in your
+ QGLViewer::draw() method, the two matrices differ.
+
+ The result is an OpenGL 4x4 matrix, which is given in \e column-major order (see \c glMultMatrix
+ man page for details).
+
+ See also getProjectionMatrix() and setFromModelViewMatrix(). */
+void AppGLWidget_Camera::getModelViewMatrix(GLdouble m[16]) const
+{
+  // May not be needed, but easier like this.
+  // Prevents from retrieving matrix in stereo mode -> overwrites shifted value.
+  computeModelViewMatrix();
+  for (unsigned short i=0; i<16; ++i)
+    m[i] = modelViewMatrix_[i];
+}
+
+/*! Fills \p m with the product of the ModelView and Projection matrices.
+
+  Calls getModelViewMatrix() and getProjectionMatrix() and then fills \p m with the product of these two matrices. */
+void AppGLWidget_Camera::getModelViewProjectionMatrix(GLdouble m[16]) const
+{
+  GLdouble mv[16];
+  GLdouble proj[16];
+  getModelViewMatrix(mv);
+  getProjectionMatrix(proj);
+	
+  for (unsigned short i=0; i<4; ++i)
+  {
+    for (unsigned short j=0; j<4; ++j)
+    {
+      double sum = 0.0;
+      for (unsigned short k=0; k<4; ++k)
+        sum += proj[i+4*k]*mv[k+4*j];
+      m[i+4*j] = sum;
+    }
+  }
+}
+
+#ifndef DOXYGEN
+void AppGLWidget_Camera::getProjectionMatrix(GLfloat m[16]) const
+{
+  cout << "Warning : AppGLWidget_Camera::getProjectionMatrix requires a GLdouble matrix array";
+  static GLdouble mat[16];
+  getProjectionMatrix(mat);
+  for (int i=0; i<16; ++i)
+    m[i] = float(mat[i]);
+}
+
+void AppGLWidget_Camera::getModelViewMatrix(GLfloat m[16]) const
+{
+  cout << "Warning : AppGLWidget_Camera::getModelViewMatrix requires a GLdouble matrix array";
+  static GLdouble mat[16];
+  getModelViewMatrix(mat);
+  for (int i=0; i<16; ++i)
+    m[i] = float(mat[i]);
+}
+#endif
+
+/*! Sets the sceneRadius() value. Negative values are ignored.
+
+\attention This methods also sets focusDistance() to sceneRadius() / tan(fieldOfView()/2) and
+flySpeed() to 1% of sceneRadius(). */
+void AppGLWidget_Camera::setSceneRadius(float radius)
+{
+  if (radius <= 0.0)
+    {
+      cout << "Scene radius must be positive - Ignoring value";
+      return;
+    }
+
+  sceneRadius_ = radius;
+
+  setFocusDistance(sceneRadius() / tan(fieldOfView()/2.0));
+
+  frame()->setFlySpeed(0.01*sceneRadius());
+}
+
+/*! Similar to setSceneRadius() and setSceneCenter(), but the scene limits are defined by a (world
+  axis aligned) bounding box. */
+void AppGLWidget_Camera::setSceneBoundingBox(const Vec& min, const Vec& max)
+{
+  setSceneCenter((min+max)/2.0);
+  setSceneRadius(0.5*(max-min).norm());
+}
+
+
+/*! Sets the sceneCenter().
+
+ \attention This method also sets the revolveAroundPoint() to sceneCenter(). */
+void AppGLWidget_Camera::setSceneCenter(const Vec& center)
+{
+  sceneCenter_ = center;
+  setRevolveAroundPoint(sceneCenter());
+}
+
+/*! setSceneCenter() to the result of pointUnderPixel(\p pixel).
+
+  Returns \c true if a pointUnderPixel() was found and sceneCenter() was actually changed.
+
+  See also setRevolveAroundPointFromPixel(). See the pointUnderPixel() documentation. */
+bool AppGLWidget_Camera::setSceneCenterFromPixel(const Point& pixel)
+{
+  bool found;
+  Vec point = pointUnderPixel(pixel, found);
+  if (found)
+    setSceneCenter(point);
+  return found;
+}
+
+/*! Changes the revolveAroundPoint() to \p rap (defined in the world coordinate system). */
+void AppGLWidget_Camera::setRevolveAroundPoint(const Vec& rap)
+{
+  const float prevDist = fabs(cameraCoordinatesOf(revolveAroundPoint()).z);
+
+  frame()->setRevolveAroundPoint(rap);
+
+  // orthoCoef_ is used to compensate for changes of the revolveAroundPoint, so that the image does
+  // not change when the revolveAroundPoint is changed in ORTHOGRAPHIC mode.
+  const float newDist = fabs(cameraCoordinatesOf(revolveAroundPoint()).z);
+  // Prevents division by zero when rap is set to camera position
+  if ((prevDist > 1E-9) && (newDist > 1E-9))
+    orthoCoef_ *= prevDist / newDist;
+}
+
+/*! The revolveAroundPoint() is set to the point located under \p pixel on screen.
+
+Returns \c true if a pointUnderPixel() was found. If no point was found under \p pixel, the
+revolveAroundPoint() is left unchanged.
+
+\p pixel is expressed in Qt format (origin in the upper left corner of the window). See
+pointUnderPixel().
+
+See also setSceneCenterFromPixel(). */
+bool AppGLWidget_Camera::setRevolveAroundPointFromPixel(const Point& pixel)
+{
+  bool found;
+  Vec point = pointUnderPixel(pixel, found);
+  if (found)
+    setRevolveAroundPoint(point);
+  return found;
+}
+
+/*! Returns the ratio between pixel and OpenGL units at \p position.
+
+ A line of \c n * pixelGLRatio() OpenGL units, located at \p position in the world coordinates
+ system, will be projected with a length of \c n pixels on screen.
+
+ Use this method to scale objects so that they have a constant pixel size on screen. The following
+ code will draw a 20 pixel line, starting at sceneCenter() and always directed along the screen
+ vertical direction:
+ \code
+ glBegin(GL_LINES);
+ glVertex3fv(sceneCenter());
+ glVertex3fv(sceneCenter() + 20 * pixelGLRatio(sceneCenter()) * camera()->upVector());
+ glEnd();
+ \endcode */
+float AppGLWidget_Camera::pixelGLRatio(const Vec& position) const
+{
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE :
+      return 2.0 * fabs((frame()->coordinatesOf(position)).z) * tan(fieldOfView()/2.0) / screenHeight();
+    case AppGLWidget_Camera::ORTHOGRAPHIC :
+      {
+	GLdouble w, h;
+	getOrthoWidthHeight(w,h);
+	return 2.0 * h / screenHeight();
+      }
+    }
+  // Bad compilers complain
+  return 1.0;
+}
+
+/*! Changes the Camera fieldOfView() so that the entire scene (defined by QGLViewer::sceneCenter()
+ and QGLViewer::sceneRadius()) is visible from the Camera position().
+
+ The position() and orientation() of the Camera are not modified and you first have to orientate the
+ Camera in order to actually see the scene (see lookAt(), showEntireScene() or fitSphere()).
+
+ This method is especially useful for \e shadow \e maps computation. Use the Camera positioning
+ tools (setPosition(), lookAt()) to position a Camera at the light position. Then use this method to
+ define the fieldOfView() so that the shadow map resolution is optimally used:
+ \code
+ // The light camera needs size hints in order to optimize its fieldOfView
+ lightCamera->setSceneRadius(sceneRadius());
+ lightCamera->setSceneCenter(sceneCenter());
+
+ // Place the light camera.
+ lightCamera->setPosition(lightFrame->position());
+ lightCamera->lookAt(sceneCenter());
+ lightCamera->setFOVToFitScene();
+ \endcode
+
+ See the (soon available) shadowMap contribution example for a practical implementation.
+
+ \attention The fieldOfView() is clamped to M_PI/2.0. This happens when the Camera is at a distance
+ lower than sqrt(2.0) * sceneRadius() from the sceneCenter(). It optimizes the shadow map
+ resolution, although it may miss some parts of the scene. */
+void AppGLWidget_Camera::setFOVToFitScene()
+{
+  if (distanceToSceneCenter() > sqrt(2.0)*sceneRadius())
+    setFieldOfView(2.0 * asin(sceneRadius() / distanceToSceneCenter()));
+  else
+    setFieldOfView(M_PI / 2.0f);
+}
+
+/*! Makes the Camera smoothly zoom on the pointUnderPixel() \p pixel.
+
+ Nothing happens if no pointUnderPixel() is found. Otherwise a KeyFrameInterpolator is created that
+ animates the Camera on a one second path that brings the Camera closer to the point under \p pixel.
+
+ See also interpolateToFitScene(). */
+// void Camera::interpolateToZoomOnPixel(const Point& pixel)
+// {
+//   const float coef = 0.1f;
+// 
+//   bool found;
+//   Vec target = pointUnderPixel(pixel, found);
+// 
+//   if (!found)
+//     return;
+// 
+//   if (interpolationKfi_->interpolationIsStarted())
+//     interpolationKfi_->stopInterpolation();
+// 
+//   interpolationKfi_->deletePath();
+//   interpolationKfi_->addKeyFrame(*(frame()));
+// 
+//   interpolationKfi_->addKeyFrame(Frame(0.3f*frame()->position() + 0.7f*target, frame()->orientation()), 0.4f);
+// 
+//   // Small hack: attach a temporary frame to take advantage of lookAt without modifying frame
+//   static ManipulatedCameraFrame* tempFrame = new ManipulatedCameraFrame();
+//   ManipulatedCameraFrame* const originalFrame = frame();
+//   tempFrame->setPosition(coef*frame()->position() + (1.0-coef)*target);
+//   tempFrame->setOrientation(frame()->orientation());
+//   setFrame(tempFrame);
+//   lookAt(target);
+//   setFrame(originalFrame);
+// 
+//   interpolationKfi_->addKeyFrame(*(tempFrame), 1.0);
+// 
+//   interpolationKfi_->startInterpolation();
+// }
+
+/*! Interpolates the Camera on a one second KeyFrameInterpolator path so that the entire scene fits
+ the screen at the end.
+
+ The scene is defined by its sceneCenter() and its sceneRadius(). See showEntireScene().
+
+ The orientation() of the Camera is not modified. See also interpolateToZoomOnPixel(). */
+// void Camera::interpolateToFitScene()
+// {
+//   if (interpolationKfi_->interpolationIsStarted())
+//     interpolationKfi_->stopInterpolation();
+// 
+//   interpolationKfi_->deletePath();
+//   interpolationKfi_->addKeyFrame(*(frame()));
+// 
+//   // Small hack:  attach a temporary frame to take advantage of lookAt without modifying frame
+//   static ManipulatedCameraFrame* tempFrame = new ManipulatedCameraFrame();
+//   ManipulatedCameraFrame* const originalFrame = frame();
+//   tempFrame->setPosition(frame()->position());
+//   tempFrame->setOrientation(frame()->orientation());
+//   setFrame(tempFrame);
+//   showEntireScene();
+//   setFrame(originalFrame);
+// 
+//   //interpolationKfi_->addKeyFrame(*(tempFrame));
+// 
+//   //interpolationKfi_->startInterpolation();
+// }
+
+
+/*! Smoothly interpolates the Camera on a KeyFrameInterpolator path so that it goes to \p fr.
+ 
+  \p fr is expressed in world coordinates. \p duration tunes the interpolation speed (default is
+  1 second).
+  
+  See also interpolateToFitScene() and interpolateToZoomOnPixel(). */
+// void Camera::interpolateTo(const Frame& fr, float duration)
+// {
+//   if (interpolationKfi_->interpolationIsStarted())
+//     interpolationKfi_->stopInterpolation();
+// 
+//   interpolationKfi_->deletePath();
+//   interpolationKfi_->addKeyFrame(*(frame()));
+//   interpolationKfi_->addKeyFrame(fr, duration);
+// 
+//   interpolationKfi_->startInterpolation();
+// }
+
+
+/*! Returns the coordinates of the 3D point located at pixel (x,y) on screen.
+
+ Calls a \c glReadPixel to get the pixel depth and applies an unprojectedCoordinatesOf() to the
+ result. \p found indicates whether a point was found or not (i.e. background pixel, result's depth
+ is zFar() in that case).
+
+ \p x and \p y are expressed in pixel units with an origin in the upper left corner. Use
+ screenHeight() - y to convert to OpenGL standard.
+
+ \attention This method assumes that a GL context is available, and that its content was drawn using
+ the Camera (i.e. using its projection and modelview matrices). This method hence cannot be used for
+ offscreen Camera computations. Use cameraCoordinatesOf() and worldCoordinatesOf() to perform
+ similar operations in that case.
+
+ \note The precision of the z-Buffer highly depends on how the zNear() and zFar() values are fitted
+ to your scene. Loose boundaries will result in imprecision along the viewing direction. */
+Vec AppGLWidget_Camera::pointUnderPixel(const Point& pixel, bool& found) const
+{
+  float depth;
+  // Qt uses upper corner for its origin while GL uses the lower corner.
+  glReadPixels(pixel.x(), screenHeight()-1-pixel.y(), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
+  found = depth < 1.0;
+  Vec point(pixel.x(), pixel.y(), depth);
+  point = unprojectedCoordinatesOf(point);
+  return point;
+}
+
+/*! Moves the Camera so that the entire scene is visible.
+
+ Simply calls fitSphere() on a sphere defined by sceneCenter() and sceneRadius().
+
+ You will typically use this method in QGLViewer::init() after you defined a new sceneRadius(). */
+void AppGLWidget_Camera::showEntireScene()
+{
+  fitSphere(sceneCenter(), sceneRadius());
+}
+
+/*! Moves the Camera so that its sceneCenter() is projected on the center of the window. The
+ orientation() and fieldOfView() are unchanged.
+
+ Simply projects the current position on a line passing through sceneCenter(). See also
+ showEntireScene().*/
+void AppGLWidget_Camera::centerScene()
+{
+  frame()->projectOnLine(sceneCenter(), viewDirection());
+}
+
+/*! Sets the Camera orientation(), so that it looks at point \p target (defined in the world
+ coordinate system).
+
+ The Camera position() is not modified. Simply setViewDirection().
+
+ See also setUpVector(), setOrientation(), showEntireScene(), fitSphere() and fitBoundingBox(). */
+void AppGLWidget_Camera::lookAt(const Vec& target)
+{
+  setViewDirection(target - position());
+}
+
+/*! Moves the Camera so that the sphere defined by (\p center, \p radius) is visible and fits the window.
+
+ The Camera is simply translated along its viewDirection() so that the sphere fits the screen. Its
+ orientation() and its fieldOfView() are unchanged.
+
+ You should therefore orientate the Camera before you call this method. See lookAt(),
+ setOrientation() and setUpVector(). */
+void AppGLWidget_Camera::fitSphere(const Vec& center, float radius)
+{
+  float distance = 0.0f;
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE :
+      {
+	const float yview = radius / sin(fieldOfView()/2.0);
+	const float xview = radius / sin(horizontalFieldOfView()/2.0);
+	distance = qMax(xview,yview);
+	break;
+      }
+    case AppGLWidget_Camera::ORTHOGRAPHIC :
+      {
+	distance = ((center-revolveAroundPoint()) * viewDirection()) + (radius / orthoCoef_);
+	break;
+      }
+    }
+  Vec newPos(center - distance * viewDirection());
+  frame()->setPositionWithConstraint(newPos);
+}
+
+/*! Moves the Camera so that the (world axis aligned) bounding box (\p min, \p max) is entirely
+  visible, using fitSphere(). */
+void AppGLWidget_Camera::fitBoundingBox(const Vec& min, const Vec& max)
+{
+  float diameter = qMax(fabs(max[1]-min[1]), fabs(max[0]-min[0]));
+  diameter = qMax(fabsf(max[2]-min[2]), diameter);
+  fitSphere(0.5*(min+max), 0.5*diameter);
+}
+
+/*! Rotates the Camera so that its upVector() becomes \p up (defined in the world coordinate
+ system).
+
+ The Camera is rotated around an axis orthogonal to \p up and to the current upVector() direction.
+ Use this method in order to define the Camera horizontal plane.
+
+ When \p noMove is set to \c false, the orientation modification is compensated by a translation, so
+ that the revolveAroundPoint() stays projected at the same position on screen. This is especially
+ useful when the Camera is an observer of the scene (default mouse binding).
+
+ When \p noMove is \c true (default), the Camera position() is left unchanged, which is an intuitive
+ behavior when the Camera is in a walkthrough fly mode (see the QGLViewer::MOVE_FORWARD and
+ QGLViewer::MOVE_BACKWARD QGLViewer::MouseAction). */
+void AppGLWidget_Camera::setUpVector(const Vec& up, bool noMove)
+{
+  Quaternion q(Vec(0.0, 1.0, 0.0), frame()->transformOf(up));
+
+  if (!noMove)
+    frame()->setPosition(revolveAroundPoint() - (frame()->orientation()*q).rotate(frame()->coordinatesOf(revolveAroundPoint())));
+
+  frame()->rotate(q);
+
+  // Useful in fly mode to keep the horizontal direction.
+  //frame()->updateFlyUpVector();
+}
+
+/*! Sets the orientation() of the Camera using polar coordinates.
+
+ \p theta rotates the Camera around its Y axis, and \e then \p phi rotates it around its X axis.
+ The polar coordinates are defined in the world coordinates system: \p theta = \p phi = 0 means
+ that the Camera is directed towards the world Z axis. Both angles are expressed in radians.
+
+ See also setUpVector(). The position() of the Camera is unchanged, you may want to call showEntireScene()
+ after this method to move the Camera.
+
+ This method can be useful to create Quicktime VR panoramic sequences, see the
+ QGLViewer::saveSnapshot() documentation for details. */
+void AppGLWidget_Camera::setOrientation(float theta, float phi)
+{
+  Vec axis(0.0, 1.0, 0.0);
+  const Quaternion rot1(axis, theta);
+  axis = Vec(-cos(theta), 0., sin(theta));
+  const Quaternion rot2(axis, phi);
+  setOrientation(rot1 * rot2);
+}
+
+/*! Sets the Camera orientation(), defined in the world coordinate system. */
+void AppGLWidget_Camera::setOrientation(const Quaternion& q)
+{
+  frame()->setOrientation(q);
+  //frame()->updateFlyUpVector();
+}
+
+/*! Rotates the Camera so that its viewDirection() is \p direction (defined in the world coordinate
+ system).
+
+ The Camera position() is not modified. The Camera is rotated so that the horizon (defined by its
+ upVector()) is preserved. See also lookAt() and setUpVector(). */
+void AppGLWidget_Camera::setViewDirection(const Vec& direction)
+{
+  if (direction.squaredNorm() < 1E-10)
+    return;
+
+  Vec xAxis = direction ^ upVector();
+  if (xAxis.squaredNorm() < 1E-10)
+    {
+      // target is aligned with upVector, this means a rotation around X axis
+      // X axis is then unchanged, let's keep it !
+      xAxis = frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0));
+    }
+
+  Quaternion q;
+  q.setFromRotatedBasis(xAxis, xAxis^direction, -direction);
+  frame()->setOrientationWithConstraint(q);
+}
+
+// Compute a 3 by 3 determinant.
+static float det(float m00,float m01,float m02,
+		 float m10,float m11,float m12,
+		 float m20,float m21,float m22)
+{
+  return m00*m11*m22 + m01*m12*m20 + m02*m10*m21 - m20*m11*m02 - m10*m01*m22 - m00*m21*m12;
+}
+
+// Computes the index of element [i][j] in a \c float matrix[3][4].
+static inline unsigned int ind(unsigned int i, unsigned int j)
+{
+  return (i*4+j);
+}
+
+
+/*! Sets the Camera's position() and orientation() from an OpenGL ModelView matrix.
+
+This enables a Camera initialisation from an other OpenGL application. \p modelView is a 16 GLdouble
+vector representing a valid OpenGL ModelView matrix, such as one can get using:
+\code
+GLdouble mvm[16];
+glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
+myCamera->setFromModelViewMatrix(mvm);
+\endcode
+
+After this method has been called, getModelViewMatrix() returns a matrix equivalent to \p
+modelView.
+
+Only the orientation() and position() of the Camera are modified.
+
+\note If you defined your matrix as \c GLdouble \c mvm[4][4], pass \c &(mvm[0][0]) as a
+parameter. */
+void AppGLWidget_Camera::setFromModelViewMatrix(const GLdouble* const modelViewMatrix)
+{
+  // Get upper left (rotation) matrix
+  double upperLeft[3][3];
+  for (int i=0; i<3; ++i)
+    for (int j=0; j<3; ++j)
+      upperLeft[i][j] = modelViewMatrix[i*4+j];
+
+  // Transform upperLeft into the associated Quaternion
+  Quaternion q;
+  q.setFromRotationMatrix(upperLeft);
+
+  setOrientation(q);
+  setPosition(-q.rotate(Vec(modelViewMatrix[12], modelViewMatrix[13], modelViewMatrix[14])));
+}
+
+/*! Defines the Camera position(), orientation() and fieldOfView() from a projection matrix.
+
+ \p matrix has to be given in the format used by vision algorithm. It has 3 lines and 4 columns. It
+ transforms a point from the world homogeneous coordinate system (4 coordinates: \c sx, \c sy, \c sz
+ and \c s) into a point in the screen homogeneous coordinate system (3 coordinates: \c sx, \c sy,
+ and \c s, where \c x and \c y are the pixel coordinates on the screen).
+
+ Its three lines correspond to the homogeneous coordinates of the normals to the planes x=0, y=0 and
+ z=0, defined in the Camera coordinate system.
+
+ The elements of the matrix are ordered in line major order: you can call \c
+ setFromProjectionMatrix(&(matrix[0][0])) if you defined your matrix as a \c float \c matrix[3][4].
+
+ \attention Passing the result of getProjectionMatrix() or getModelViewMatrix() to this method is
+ not possible (purposefully incompatible matrix dimensions). \p matrix is more likely to be the
+ product of these two matrices, without the last line.
+
+ Use setFromModelViewMatrix() to set position() and orientation() from a \c GL_MODELVIEW matrix.
+ fieldOfView() can also be retrieved from a \e perspective \c GL_PROJECTION matrix using 2.0 *
+ atan(1.0/projectionMatrix[5]).
+
+ This code was written by Sylvain Paris. */
+void AppGLWidget_Camera::setFromProjectionMatrix(const float matrix[12])
+{
+  // The 3 lines of the matrix are the normals to the planes x=0, y=0, z=0
+  // in the camera CS. As we normalize them, we do not need the 4th coordinate.
+  Vec line_0(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,2)]);
+  Vec line_1(matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,2)]);
+  Vec line_2(matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,2)]);
+
+  line_0.normalize();
+  line_1.normalize();
+  line_2.normalize();
+
+  // The camera position is at (0,0,0) in the camera CS so it is the
+  // intersection of the 3 planes. It can be seen as the kernel
+  // of the 3x4 projection matrix. We calculate it through 4 dimensional
+  // vectorial product. We go directly into 3D that is to say we directly
+  // divide the first 3 coordinates by the 4th one.
+
+  // We derive the 4 dimensional vectorial product formula from the
+  // computation of a 4x4 determinant that is developped according to
+  // its 4th column. This implies some 3x3 determinants.
+  const Vec cam_pos = Vec(det(matrix[ind(0,1)],matrix[ind(0,2)],matrix[ind(0,3)],
+			      matrix[ind(1,1)],matrix[ind(1,2)],matrix[ind(1,3)],
+			      matrix[ind(2,1)],matrix[ind(2,2)],matrix[ind(2,3)]),
+
+			   -det(matrix[ind(0,0)],matrix[ind(0,2)],matrix[ind(0,3)],
+				matrix[ind(1,0)],matrix[ind(1,2)],matrix[ind(1,3)],
+				matrix[ind(2,0)],matrix[ind(2,2)],matrix[ind(2,3)]),
+
+			   det(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,3)],
+			       matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,3)],
+			       matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,3)])) /
+
+    (-det(matrix[ind(0,0)],matrix[ind(0,1)],matrix[ind(0,2)],
+	  matrix[ind(1,0)],matrix[ind(1,1)],matrix[ind(1,2)],
+	  matrix[ind(2,0)],matrix[ind(2,1)],matrix[ind(2,2)]));
+
+  // We compute the rotation matrix column by column.
+
+  // GL Z axis is front facing.
+  Vec column_2 = -line_2;
+
+  // X-axis is almost like line_0 but should be orthogonal to the Z axis.
+  Vec column_0 = ((column_2^line_0)^column_2);
+  column_0.normalize();
+
+  // Y-axis is almost like line_1 but should be orthogonal to the Z axis.
+  // Moreover line_1 is downward oriented as the screen CS.
+  Vec column_1 = -((column_2^line_1)^column_2);
+  column_1.normalize();
+
+  double rot[3][3];
+  rot[0][0] = column_0[0];
+  rot[1][0] = column_0[1];
+  rot[2][0] = column_0[2];
+
+  rot[0][1] = column_1[0];
+  rot[1][1] = column_1[1];
+  rot[2][1] = column_1[2];
+
+  rot[0][2] = column_2[0];
+  rot[1][2] = column_2[1];
+  rot[2][2] = column_2[2];
+
+  // We compute the field of view
+
+  // line_1^column_0 -> vector of intersection line between
+  // y_screen=0 and x_camera=0 plane.
+  // column_2*(...)  -> cos of the angle between Z vector et y_screen=0 plane
+  // * 2 -> field of view = 2 * half angle
+
+  // We need some intermediate values.
+  Vec dummy = line_1^column_0;
+  dummy.normalize();
+  float fov = acos(column_2*dummy) * 2.0;
+
+  // We set the camera.
+  Quaternion q;
+  q.setFromRotationMatrix(rot);
+  setOrientation(q);
+  setPosition(cam_pos);
+  setFieldOfView(fov);
+}
+
+
+/*
+	// persp : projectionMatrix_[0]  = f/aspectRatio();
+void Camera::setFromProjectionMatrix(const GLdouble* projectionMatrix)
+{
+  QString message;
+  if ((fabs(projectionMatrix[1]) > 1E-3) ||
+      (fabs(projectionMatrix[2]) > 1E-3) ||
+      (fabs(projectionMatrix[3]) > 1E-3) ||
+      (fabs(projectionMatrix[4]) > 1E-3) ||
+      (fabs(projectionMatrix[6]) > 1E-3) ||
+      (fabs(projectionMatrix[7]) > 1E-3) ||
+      (fabs(projectionMatrix[8]) > 1E-3) ||
+      (fabs(projectionMatrix[9]) > 1E-3))
+    message = "Non null coefficient in projection matrix - Aborting";
+  else
+    if ((fabs(projectionMatrix[11]+1.0) < 1E-5) && (fabs(projectionMatrix[15]) < 1E-5))
+      {
+	if (projectionMatrix[5] < 1E-4)
+	  message="Negative field of view in Camera::setFromProjectionMatrix";
+	else
+	  setType(Camera::PERSPECTIVE);
+      }
+    else
+      if ((fabs(projectionMatrix[11]) < 1E-5) && (fabs(projectionMatrix[15]-1.0) < 1E-5))
+	setType(Camera::ORTHOGRAPHIC);
+      else
+	message = "Unable to determine camera type in setFromProjectionMatrix - Aborting";
+
+  if (!message.isEmpty())
+    {
+      qWarning(message);
+      return;
+    }
+
+  switch (type())
+    {
+    case Camera::PERSPECTIVE:
+      {
+	setFieldOfView(2.0 * atan(1.0/projectionMatrix[5]));
+	const float far = projectionMatrix[14] / (2.0 * (1.0 + projectionMatrix[10]));
+	const float near = (projectionMatrix[10]+1.0) / (projectionMatrix[10]-1.0) * far;
+	setSceneRadius((far-near)/2.0);
+	setSceneCenter(position() + (near + sceneRadius())*viewDirection());
+	break;
+      }
+    case Camera::ORTHOGRAPHIC:
+      {
+	GLdouble w, h;
+	getOrthoWidthHeight(w,h);
+	projectionMatrix_[0]  = 1.0/w;
+	projectionMatrix_[5]  = 1.0/h;
+	projectionMatrix_[10] = -2.0/(ZFar - ZNear);
+	projectionMatrix_[11] = 0.0;
+	projectionMatrix_[14] = -(ZFar + ZNear)/(ZFar - ZNear);
+	projectionMatrix_[15] = 1.0;
+	// same as glOrtho( -w, w, -h, h, zNear(), zFar() );
+	break;
+      }
+    }
+}
+*/
+
+///////////////////////// Camera to world transform ///////////////////////
+
+/*! Same as cameraCoordinatesOf(), but with \c float[3] parameters (\p src and \p res may be identical pointers). */
+void AppGLWidget_Camera::getCameraCoordinatesOf(const float src[3], float res[3]) const
+{
+  Vec r = cameraCoordinatesOf(Vec(src));
+  for (int i=0; i<3; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as worldCoordinatesOf(), but with \c float[3] parameters (\p src and \p res may be identical pointers). */
+void AppGLWidget_Camera::getWorldCoordinatesOf(const float src[3], float res[3]) const
+{
+  Vec r = worldCoordinatesOf(Vec(src));
+  for (int i=0; i<3; ++i)
+    res[i] = r[i];
+}
+
+/*! Fills \p viewport with the Camera OpenGL viewport.
+
+This method is mainly used in conjunction with \c gluProject, which requires such a viewport.
+Returned values are (0, screenHeight(), screenWidth(), - screenHeight()), so that the origin is
+located in the \e upper left corner of the window (Qt style coordinate system). */
+void AppGLWidget_Camera::getViewport(GLint viewport[4]) const
+{
+  viewport[0] = 0;
+  viewport[1] = screenHeight();
+  viewport[2] = screenWidth();
+  viewport[3] = -screenHeight();
+}
+
+/*! Returns the screen projected coordinates of a point \p src defined in the \p frame coordinate
+ system.
+
+ When \p frame in \c NULL (default), \p src is expressed in the world coordinate system.
+
+ The x and y coordinates of the returned Vec are expressed in pixel, (0,0) being the \e upper left
+ corner of the window. The z coordinate ranges between 0.0 (near plane) and 1.0 (excluded, far
+ plane). See the \c gluProject man page for details.
+
+ unprojectedCoordinatesOf() performs the inverse transformation.
+
+ See the <a href="../examples/screenCoordSystem.html">screenCoordSystem example</a>.
+
+ This method only uses the intrinsic Camera parameters (see getModelViewMatrix(),
+ getProjectionMatrix() and getViewport()) and is completely independent of the OpenGL \c
+ GL_MODELVIEW, \c GL_PROJECTION and viewport matrices. You can hence define a virtual Camera and use
+ this method to compute projections out of a classical rendering context.
+
+ \attention However, if your Camera is not attached to a QGLViewer (used for offscreen computations
+ for instance), make sure the Camera matrices are updated before calling this method. Call
+ computeModelViewMatrix() and computeProjectionMatrix() to do so.
+
+ If you call this method several times with no change in the matrices, consider precomputing the
+ projection times modelview matrix to save computation time if required (\c P x \c M in the \c
+ gluProject man page). */
+Vec AppGLWidget_Camera::projectedCoordinatesOf(const Vec& src, const Frame* frame) const
+{
+  GLdouble x,y,z;
+  static GLint viewport[4];
+  getViewport(viewport);
+
+  if (frame)
+    {
+      const Vec tmp = frame->inverseCoordinatesOf(src);
+      gluProject(tmp.x,tmp.y,tmp.z, modelViewMatrix_, projectionMatrix_, viewport,  &x,&y,&z);
+    }
+  else
+    gluProject(src.x,src.y,src.z, modelViewMatrix_, projectionMatrix_, viewport,  &x,&y,&z);
+
+  return Vec(x,y,z);
+}
+
+/*! Returns the world unprojected coordinates of a point \p src defined in the screen coordinate
+ system.
+
+ The \p src.x and \p src.y input values are expressed in pixels, (0,0) being the \e upper left corner
+ of the window. \p src.z is a depth value ranging in [0..1[ (near and far plane respectively). See
+ the \c gluUnProject man page for details.
+
+ The result is expressed in the \p frame coordinate system. When \p frame is \c NULL (default), the
+ result is expressed in the world coordinates system. The possible \p frame Frame::referenceFrame()
+ are taken into account.
+
+ projectedCoordinatesOf() performs the inverse transformation.
+
+ This method only uses the intrinsic Camera parameters (see getModelViewMatrix(),
+ getProjectionMatrix() and getViewport()) and is completely independent of the OpenGL \c
+ GL_MODELVIEW, \c GL_PROJECTION and viewport matrices. You can hence define a virtual Camera and use
+ this method to compute un-projections out of a classical rendering context.
+
+ \attention However, if your Camera is not attached to a QGLViewer (used for offscreen computations
+ for instance), make sure the Camera matrices are updated before calling this method (use
+ computeModelViewMatrix(), computeProjectionMatrix()). See also setScreenWidthAndHeight().
+
+ This method is not computationally optimized. If you call it several times with no change in the
+ matrices, you should buffer the entire inverse projection matrix (modelview, projection and then
+ viewport) to speed-up the queries. See the \c gluUnProject man page for details. */
+Vec AppGLWidget_Camera::unprojectedCoordinatesOf(const Vec& src, const Frame* frame) const
+{
+  GLdouble x,y,z;
+  static GLint viewport[4];
+  getViewport(viewport);
+  gluUnProject(src.x,src.y,src.z, modelViewMatrix_,  projectionMatrix_,  viewport,  &x,&y,&z);
+  if (frame)
+    return frame->coordinatesOf(Vec(x,y,z));
+  else
+    return Vec(x,y,z);
+}
+
+/*! Same as projectedCoordinatesOf(), but with \c float parameters (\p src and \p res can be identical pointers). */
+void AppGLWidget_Camera::getProjectedCoordinatesOf(const float src[3], float res[3], const Frame* frame) const
+{
+  Vec r = projectedCoordinatesOf(Vec(src), frame);
+  for (int i=0; i<3; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as unprojectedCoordinatesOf(), but with \c float parameters (\p src and \p res can be identical pointers). */
+void AppGLWidget_Camera::getUnprojectedCoordinatesOf(const float src[3], float res[3], const Frame* frame) const
+{
+  Vec r = unprojectedCoordinatesOf(Vec(src), frame);
+  for (int i=0; i<3; ++i)
+    res[i] = r[i];
+}
+
+/////////////////////////////////////  KFI /////////////////////////////////////////
+
+/*! Returns the KeyFrameInterpolator that defines the Camera path number \p i.
+
+If path \p i is not defined for this index, the method returns a \c NULL pointer. */
+// KeyFrameInterpolator* Camera::keyFrameInterpolator(int i)
+// {	
+//   if ( kfi_.find(i) != kfi_.end())
+//     return kfi_[i];
+//   else
+//     return NULL;
+// }
+
+/*! Sets the KeyFrameInterpolator that defines the Camera path of index \p i.
+
+ The previous keyFrameInterpolator() is lost and should be deleted by the calling method if
+ needed.
+
+ The KeyFrameInterpolator::interpolated() signal of \p kfi probably needs to be connected to the
+ Camera's associated QGLViewer::updateGL() slot, so that when the Camera position is interpolated
+ using \p kfi, every interpolation step updates the display:
+ \code
+ myViewer.camera()->deletePath(3);
+ myViewer.camera()->setKeyFrameInterpolator(3, myKeyFrameInterpolator);
+ connect(myKeyFrameInterpolator, SIGNAL(interpolated()), myViewer, SLOT(updateGL());
+ \endcode
+
+ \note These connections are done automatically when a Camera is attached to a QGLViewer, or when a
+ new KeyFrameInterpolator is defined using the QGLViewer::addKeyFrameKeyboardModifiers() and
+ QGLViewer::pathKey() (default is Alt+F[1-12]). See the <a href="../keyboard.html">keyboard page</a>
+ for details. */
+// void Camera::setKeyFrameInterpolator(int i, KeyFrameInterpolator* const kfi)
+// {
+//   if (kfi)
+//     kfi_[i] = kfi;
+//   else
+//     kfi_.erase(i);
+// }
+
+/*! Adds the current Camera position() and orientation() as a keyFrame to the path number \p i.
+
+This method can also be used if you simply want to save a Camera point of view (a path made of a
+single keyFrame). Use playPath() to make the Camera play the keyFrame path (resp. restore
+the point of view). Use deletePath() to clear the path.
+
+The default keyboard shortcut for this method is Alt+F[1-12]. Set QGLViewer::pathKey() and
+QGLViewer::addKeyFrameKeyboardModifiers().
+
+If you use directly this method and the keyFrameInterpolator(i) does not exist, a new one is
+created. Its KeyFrameInterpolator::interpolated() signal should then be connected to the
+QGLViewer::updateGL() slot (see setKeyFrameInterpolator()). */
+// void Camera::addKeyFrameToPath(int i)
+// {
+//     if (kfi_.find(i) != kfi_.end())
+//     setKeyFrameInterpolator(i, new KeyFrameInterpolator(frame()));
+// 
+//   kfi_[i]->addKeyFrame(*(frame()));
+// }
+
+/*! Makes the Camera follow the path of keyFrameInterpolator() number \p i.
+
+ If the interpolation is started, it stops it instead.
+
+ This method silently ignores undefined (empty) paths (see keyFrameInterpolator()).
+
+ The default keyboard shortcut for this method is F[1-12]. Set QGLViewer::pathKey() and
+ QGLViewer::playPathKeyboardModifiers(). */
+// void Camera::playPath(int i)
+// {
+//    if (kfi_.find(i) != kfi_.end())
+//     if (kfi_[i]->interpolationIsStarted())
+//       kfi_[i]->stopInterpolation();
+//     else
+//       kfi_[i]->startInterpolation();
+// }
+
+/*! Resets the path of the keyFrameInterpolator() number \p i.
+
+If this path is \e not being played (see playPath() and
+KeyFrameInterpolator::interpolationIsStarted()), resets it to is its starting position (see
+KeyFrameInterpolator::resetInterpolation()). If the path is played, simply stops interpolation. */
+// void Camera::resetPath(int i)
+// {
+// //  if (kfi_.contains(i))
+//   if (kfi_.find(i) != kfi_.end())
+//     if ((kfi_[i]->interpolationIsStarted()))
+//       kfi_[i]->stopInterpolation();
+//     else
+//       {
+// 	kfi_[i]->resetInterpolation();
+// 	kfi_[i]->interpolateAtTime(kfi_[i]->interpolationTime());
+//       }
+// }
+
+/*! Deletes the keyFrameInterpolator() of index \p i.
+
+Disconnect the keyFrameInterpolator() KeyFrameInterpolator::interpolated() signal before deleting the
+keyFrameInterpolator() if needed:
+\code
+disconnect(camera()->keyFrameInterpolator(i), SIGNAL(interpolated()), this, SLOT(updateGL()));
+camera()->deletePath(i);
+\endcode */
+// void Camera::deletePath(int i)
+// {
+//   if (kfi_.find(i) != kfi_.end())
+//     {
+//       kfi_[i]->stopInterpolation();
+//       delete kfi_[i];
+//       kfi_.erase(i);
+//     }
+// }
+
+
+
+/*! Gives the coefficients of a 3D half-line passing through the Camera eye and pixel (x,y).
+
+ The origin of the half line (eye position) is stored in \p orig, while \p dir contains the properly
+ oriented and normalized direction of the half line.
+
+ \p x and \p y are expressed in Qt format (origin in the upper left corner). Use screenHeight() - y
+ to convert to OpenGL units.
+
+ This method is useful for analytical intersection in a selection method.
+
+ See the <a href="../examples/select.html">select example</a> for an illustration. */
+void AppGLWidget_Camera::convertClickToLine(const Point& pixel, Vec& orig, Vec& dir) const
+{
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE:
+      orig = position();
+      dir = Vec( ((2.0 * pixel.x() / screenWidth()) - 1.0) * tan(fieldOfView()/2.0) * aspectRatio(),
+		 ((2.0 * (screenHeight()-pixel.y()) / screenHeight()) - 1.0) * tan(fieldOfView()/2.0),
+		 -1.0 );
+      dir = worldCoordinatesOf(dir) - orig;
+      dir.normalize();
+      break;
+
+    case AppGLWidget_Camera::ORTHOGRAPHIC:
+      {
+	GLdouble w,h;
+	getOrthoWidthHeight(w,h);
+	orig = Vec((2.0 * pixel.x() / screenWidth() - 1.0)*w, -(2.0 * pixel.y() / screenHeight() - 1.0)*h, 0.0);
+	orig = worldCoordinatesOf(orig);
+	dir = viewDirection();
+	break;
+      }
+    }
+}
+
+#ifndef DOXYGEN
+/*! This method has been deprecated in libQGLViewer version 2.2.0 */
+void AppGLWidget_Camera::drawCamera(float, float, float)
+{
+  cout << "drawCamera is deprecated. Use AppGLWidget_Camera::draw() instead.";
+}
+#endif
+
+/*! Draws a representation of the Camera in the 3D world.
+
+The near and far planes are drawn as quads, the frustum is drawn using lines and the camera up
+vector is represented by an arrow to disambiguate the drawing. See the 
+<a href="../examples/standardCamera.html">standardCamera example</a> for an illustration.
+
+Note that the current \c glColor and \c glPolygonMode are used to draw the near and far planes. See
+the <a href="../examples/frustumCulling.html">frustumCulling example</a> for an example of
+semi-transparent plane drawing. Similarly, the current \c glLineWidth and \c glColor is used to draw
+the frustum outline.
+
+When \p drawFarPlane is \c false, only the near plane is drawn. \p scale can be used to scale the
+drawing: a value of 1.0 (default) will draw the Camera's frustum at its actual size.
+
+This method assumes that the \c glMatrixMode is \c GL_MODELVIEW and that the current ModelView
+matrix corresponds to the world coordinate system (as it is at the beginning of QGLViewer::draw()).
+The Camera is then correctly positioned and orientated.
+
+\note The drawing of a QGLViewer's own QGLViewer::camera() should not be visible, but may create
+artefacts due to numerical imprecisions. */
+void AppGLWidget_Camera::draw(bool drawFarPlane, float scale) const
+{
+  glPushMatrix();
+  glMultMatrixd(frame()->worldMatrix());
+
+  // 0 is the upper left coordinates of the near corner, 1 for the far one
+  Vec points[2];
+
+  points[0].z = scale * zNear();
+  points[1].z = scale * zFar();
+
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE:
+      {
+	points[0].y = points[0].z * tan(fieldOfView()/2.0);
+	points[0].x = points[0].y * aspectRatio();
+
+	const float ratio = points[1].z / points[0].z;
+
+	points[1].y = ratio * points[0].y;
+	points[1].x = ratio * points[0].x;
+	break;
+      }
+    case AppGLWidget_Camera::ORTHOGRAPHIC:
+      {
+	GLdouble hw, hh;
+	getOrthoWidthHeight(hw, hh);
+	points[0].x = points[1].x = scale * float(hw);
+	points[0].y = points[1].y = scale * float(hh);
+	break;
+      }
+    }
+
+  const int farIndex = drawFarPlane?1:0;
+
+  // Near and (optionally) far plane(s)
+  glBegin(GL_QUADS);
+  for (int i=farIndex; i>=0; --i)
+    {
+      glNormal3f(0.0, 0.0, (i==0)?1.0:-1.0);
+      glVertex3f( points[i].x,  points[i].y, -points[i].z);
+      glVertex3f(-points[i].x,  points[i].y, -points[i].z);
+      glVertex3f(-points[i].x, -points[i].y, -points[i].z);
+      glVertex3f( points[i].x, -points[i].y, -points[i].z);
+    }
+  glEnd();
+
+  // Up arrow
+  const float arrowHeight    = 1.5f * points[0].y;
+  const float baseHeight     = 1.2f * points[0].y;
+  const float arrowHalfWidth = 0.5f * points[0].x;
+  const float baseHalfWidth  = 0.3f * points[0].x;
+
+  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+  // Base
+  glBegin(GL_QUADS);
+  glVertex3f(-baseHalfWidth, points[0].y, -points[0].z);
+  glVertex3f( baseHalfWidth, points[0].y, -points[0].z);
+  glVertex3f( baseHalfWidth, baseHeight,  -points[0].z);
+  glVertex3f(-baseHalfWidth, baseHeight,  -points[0].z);
+  glEnd();
+
+  // Arrow
+  glBegin(GL_TRIANGLES);
+  glVertex3f( 0.0f,           arrowHeight, -points[0].z);
+  glVertex3f(-arrowHalfWidth, baseHeight,  -points[0].z);
+  glVertex3f( arrowHalfWidth, baseHeight,  -points[0].z);
+  glEnd();
+  
+  // Frustum lines
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE :
+      glBegin(GL_LINES);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glVertex3f( points[farIndex].x,  points[farIndex].y, -points[farIndex].z);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glVertex3f(-points[farIndex].x,  points[farIndex].y, -points[farIndex].z);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glVertex3f(-points[farIndex].x, -points[farIndex].y, -points[farIndex].z);
+      glVertex3f(0.0f, 0.0f, 0.0f);
+      glVertex3f( points[farIndex].x, -points[farIndex].y, -points[farIndex].z);
+      glEnd();
+      break;
+    case AppGLWidget_Camera::ORTHOGRAPHIC :
+      if (drawFarPlane)
+	{
+	  glBegin(GL_LINES);
+	  glVertex3f( points[0].x,  points[0].y, -points[0].z);
+	  glVertex3f( points[1].x,  points[1].y, -points[1].z);
+	  glVertex3f(-points[0].x,  points[0].y, -points[0].z);
+	  glVertex3f(-points[1].x,  points[1].y, -points[1].z);
+	  glVertex3f(-points[0].x, -points[0].y, -points[0].z);
+	  glVertex3f(-points[1].x, -points[1].y, -points[1].z);
+	  glVertex3f( points[0].x, -points[0].y, -points[0].z);
+	  glVertex3f( points[1].x, -points[1].y, -points[1].z);
+	  glEnd();
+	}
+    }
+
+  glPopMatrix();
+}
+
+
+/*! Returns the 6 plane equations of the Camera frustum.
+
+The six 4-component vectors of \p coef respectively correspond to the left, right, near, far, top
+and bottom Camera frustum planes. Each vector holds a plane equation of the form:
+\code
+a*x + b*y + c*z + d = 0 
+\endcode
+where \c a, \c b, \c c and \c d are the 4 components of each vector, in that order.
+
+See the <a href="../examples/frustumCulling.html">frustumCulling example</a> for an application.
+
+This format is compatible with the \c glClipPlane() function. One camera frustum plane can hence be
+applied in an other viewer to visualize the culling results:
+\code
+ // Retrieve plance equations
+ GLdouble coef[6][4];
+ mainViewer->camera()->getFrustumPlanesCoefficients(coef);
+
+ // These two additional clipping planes (which must have been enabled)
+ // will reproduce the mainViewer's near and far clipping.
+ glClipPlane(GL_CLIP_PLANE0, coef[2]);
+ glClipPlane(GL_CLIP_PLANE1, coef[3]);
+\endcode */
+void AppGLWidget_Camera::getFrustumPlanesCoefficients(GLdouble coef[6][4]) const
+{
+  // Computed once and for all
+  const Vec pos          = position();
+  const Vec viewDir      = viewDirection();
+  const Vec up           = upVector();
+  const Vec right        = rightVector();
+  const float posViewDir = pos * viewDir;
+
+  static Vec normal[6];
+  static GLdouble dist[6];
+  
+  switch (type())
+    {
+    case AppGLWidget_Camera::PERSPECTIVE :
+      {
+	const float hhfov = horizontalFieldOfView() / 2.0;
+	const float chhfov = cos(hhfov);
+	const float shhfov = sin(hhfov);
+	normal[0] = - shhfov * viewDir;
+	normal[1] = normal[0] + chhfov * right;
+	normal[0] = normal[0] - chhfov * right;
+	
+	normal[2] = -viewDir;
+	normal[3] =  viewDir;
+	
+	const float hfov = fieldOfView() / 2.0;
+	const float chfov = cos(hfov);
+	const float shfov = sin(hfov);
+	normal[4] = - shfov * viewDir;
+	normal[5] = normal[4] - chfov * up;
+	normal[4] = normal[4] + chfov * up;
+
+	for (int i=0; i<2; ++i)
+	  dist[i] = pos * normal[i];
+	for (int j=4; j<6; ++j)
+	  dist[j] = pos * normal[j];
+
+	// Natural equations are:
+	// dist[0,1,4,5] = pos * normal[0,1,4,5];
+	// dist[2] = (pos + zNear() * viewDir) * normal[2];
+	// dist[3] = (pos + zFar()  * viewDir) * normal[3];
+
+	// 2 times less computations using expanded/merged equations. Dir vectors are normalized.
+	const float posRightCosHH = chhfov * pos * right;
+	dist[0] = -shhfov * posViewDir;
+	dist[1] = dist[0] + posRightCosHH;
+	dist[0] = dist[0] - posRightCosHH;
+	const float posUpCosH = chfov * pos * up;
+	dist[4] = - shfov * posViewDir;
+	dist[5] = dist[4] - posUpCosH;
+	dist[4] = dist[4] + posUpCosH;
+	
+	break;
+      }
+    case AppGLWidget_Camera::ORTHOGRAPHIC :
+      normal[0] = -right;
+      normal[1] =  right;
+      normal[4] =  up;
+      normal[5] = -up;
+
+      GLdouble hw, hh;
+      getOrthoWidthHeight(hw, hh);
+      dist[0] = (pos - hw * right) * normal[0];
+      dist[1] = (pos + hw * right) * normal[1];
+      dist[4] = (pos + hh * up) * normal[4];
+      dist[5] = (pos - hh * up) * normal[5];
+      break;
+    }
+
+  // Front and far planes are identical for both camera types.
+  normal[2] = -viewDir;
+  normal[3] =  viewDir;
+  dist[2] = -posViewDir - zNear();
+  dist[3] =  posViewDir + zFar();
+
+  for (int i=0; i<6; ++i)
+    {
+      coef[i][0] = GLdouble(normal[i].x);
+      coef[i][1] = GLdouble(normal[i].y);
+      coef[i][2] = GLdouble(normal[i].z);
+      coef[i][3] = dist[i];
+    }
+}
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.h
new file mode 100644
index 00000000000..e71e85839b1
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_camera.h
@@ -0,0 +1,565 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_CAMERA_H
+#define QGLVIEWER_CAMERA_H
+
+#include "AppGLWidget_manipulatedCameraFrame.h"
+
+  /*! \brief A perspective or orthographic camera.
+  \class Camera camera.h QGLViewer/camera.h
+
+  A Camera defines some intrinsic parameters (fieldOfView(), position(), viewDirection(),
+  upVector()...) and useful positioning tools that ease its placement (showEntireScene(),
+  fitSphere(), lookAt()...). It exports its associated OpenGL projection and modelview matrices and
+  can interactively be modified using the mouse.
+
+  <h3>Mouse manipulation</h3>
+
+  The position() and orientation() of the Camera are defined by a ManipulatedCameraFrame (retrieved
+  using frame()). These methods are just convenient wrappers to the equivalent Frame methods. This
+  also means that the Camera frame() can be attached to a Frame::referenceFrame() which enables
+  complex Camera setups.
+
+  Different displacements can be performed using the mouse. The list of possible actions is defined
+  by the QGLViewer::MouseAction enum. Use QGLViewer::setMouseBinding() to attach a specific action
+  to an arbitrary mouse button-state key binding. These actions are detailed in the <a
+  href="../mouse.html">mouse page</a>.
+
+  The default button binding are: QGLViewer::ROTATE (left), QGLViewer::ZOOM (middle) and
+  QGLViewer::TRANSLATE (right). With this configuration, the Camera \e observes a scene and rotates
+  around its revolveAroundPoint(). You can switch between this mode and a fly mode using the
+  QGLViewer::CAMERA_MODE (see QGLViewer::toggleCameraMode()) keyboard shortcut (default is 'Space').
+
+  <h3>Other functionalities</h3>
+
+  The type() of the Camera can be Camera::ORTHOGRAPHIC or Camera::PERSPECTIVE (see Type()).
+  fieldOfView() is meaningless with Camera::ORTHOGRAPHIC.
+
+  The near and far planes of the Camera are fitted to the scene and determined from
+  QGLViewer::sceneRadius(), QGLViewer::sceneCenter() and zClippingCoefficient() by the zNear() and
+  zFar() methods. Reasonable values on the scene extends hence have to be provided to the QGLViewer
+  in order for the Camera to correctly display the scene. High level positioning methods also use
+  this information (showEntireScene(), centerScene()...).
+
+  A Camera holds KeyFrameInterpolator that can be used to save Camera positions and paths. You can
+  interactively addKeyFrameToPath() to a given path using the default \c Alt+F[1-12] shortcuts. Use
+  playPath() to make the Camera follow the path (default shortcut is F[1-12]). See the <a
+  href="../keyboard.html">keyboard page</a> for details on key customization.
+
+  Use cameraCoordinatesOf() and worldCoordinatesOf() to convert to and from the Camera frame()
+  coordinate system. projectedCoordinatesOf() and unprojectedCoordinatesOf() will convert from
+  screen to 3D coordinates. convertClickToLine() is very useful for analytical object selection.
+
+  Stereo display is possible on machines with quad buffer capabilities (with Camera::PERSPECTIVE
+  type() only). Test the <a href="../examples/stereoViewer.html">stereoViewer example</a> to check.
+
+  A Camera can also be used outside of a QGLViewer or even without OpenGL for its coordinate system
+  conversion capabilities. Note however that some of them explicitly rely on the presence of a
+  Z-buffer. \nosubgrouping */
+  class AppGLWidget_Camera
+  {
+
+  public:
+    AppGLWidget_Camera();
+    virtual ~AppGLWidget_Camera();
+
+    AppGLWidget_Camera(const AppGLWidget_Camera& camera);
+    AppGLWidget_Camera& operator=(const AppGLWidget_Camera& camera);
+
+
+    /*! Enumerates the two possible types of Camera.
+
+    See type() and setType(). This type mainly defines different Camera projection matrix (see
+    loadProjectionMatrix()). Many other methods (pointUnderPixel(), convertClickToLine(),
+    projectedCoordinatesOf(), pixelGLRatio()...) take this Type into account. */
+    enum Type { PERSPECTIVE, ORTHOGRAPHIC };
+
+    /*! @name Position and orientation */
+    //@{
+  public:
+    /*! Returns the Camera position (the eye), defined in the world coordinate system.
+
+    Use setPosition() to set the Camera position. Other convenient methods are showEntireScene() or
+    fitSphere(). Actually returns \c frame()->position().
+
+    This position corresponds to the projection center of a Camera::PERSPECTIVE Camera. It is not
+    located in the image plane, which is at a zNear() distance ahead. */
+    Vec position() const { return frame()->position(); };
+
+    /*! Returns the normalized up vector of the Camera, defined in the world coordinate system.
+
+    Set using setUpVector() or setOrientation(). It is orthogonal to viewDirection() and to
+    rightVector().
+
+    It corresponds to the Y axis of the associated frame() (actually returns
+    frame()->inverseTransformOf(Vec(0.0, 1.0, 0.0)) ). */
+    Vec upVector() const
+    {
+      return frame()->inverseTransformOf(Vec(0.0, 1.0, 0.0));
+    }
+    /*! Returns the normalized view direction of the Camera, defined in the world coordinate system.
+
+    Change this value using setViewDirection(), lookAt() or setOrientation(). It is orthogonal to
+    upVector() and to rightVector().
+
+    This corresponds to the negative Z axis of the frame() ( frame()->inverseTransformOf(Vec(0.0,
+    0.0, -1.0)) ). */
+    Vec viewDirection() const { return frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)); };
+
+    /*! Returns the normalized right vector of the Camera, defined in the world coordinate system.
+
+    This vector lies in the Camera horizontal plane, directed along the X axis (orthogonal to
+    upVector() and to viewDirection()). Set using setUpVector(), lookAt() or setOrientation().
+
+    Simply returns frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0)). */
+    Vec rightVector() const
+    {
+      return frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0));
+    }
+
+    /*! Returns the Camera orientation, defined in the world coordinate system.
+
+    Actually returns \c frame()->orientation(). Use setOrientation(), setUpVector() or lookAt() to
+    set the Camera orientation. */
+    Quaternion orientation() const { return frame()->orientation(); };
+
+    void setFromModelViewMatrix(const GLdouble* const modelViewMatrix);
+    void setFromProjectionMatrix(const float matrix[12]);
+
+  public:
+    /*! Sets the Camera position() (the eye), defined in the world coordinate system. */
+    void setPosition(const Vec& pos) { frame()->setPosition(pos); };
+    void setOrientation(const Quaternion& q);
+    void setOrientation(float theta, float phi);
+    void setUpVector(const Vec& up, bool noMove=true);
+    void setViewDirection(const Vec& direction);
+    //@}
+
+
+    /*! @name Positioning tools */
+    //@{
+  public:
+    void lookAt(const Vec& target);
+    void showEntireScene();
+    void fitSphere(const Vec& center, float radius);
+    void fitBoundingBox(const Vec& min, const Vec& max);
+    void centerScene();
+    void interpolateToZoomOnPixel(const Point& pixel);
+    void interpolateToFitScene();
+    void interpolateTo(const Frame& fr, float duration);
+    //@}
+
+
+    /*! @name Frustum */
+    //@{
+  public:
+    /*! Returns the Camera::Type of the Camera.
+
+    Set by setType(). Mainly used by loadProjectionMatrix().
+
+    A Camera::PERSPECTIVE Camera uses a classical projection mainly defined by its fieldOfView().
+
+    With a Camera::ORTHOGRAPHIC type(), the fieldOfView() is meaningless and the width and height of
+    the Camera frustum are inferred from the distance to the revolveAroundPoint() using
+    getOrthoWidthHeight().
+
+    Both types use zNear() and zFar() (to define their clipping planes) and aspectRatio() (for
+    frustum shape). */
+    Type type() const { return type_; };
+
+    /*! Returns the vertical field of view of the Camera (in radians).
+
+    Value is set using setFieldOfView(). Default value is pi/4 radians. This value is meaningless if
+    the Camera type() is Camera::ORTHOGRAPHIC.
+
+    The field of view corresponds the one used in \c gluPerspective (see manual). It sets the Y
+    (vertical) aperture of the Camera. The X (horizontal) angle is inferred from the window aspect
+    ratio (see aspectRatio() and horizontalFieldOfView()).
+
+    Use setFOVToFitScene() to adapt the fieldOfView() to a given scene. */
+    float fieldOfView() const { return fieldOfView_; };
+
+    /*! Returns the horizontal field of view of the Camera (in radians).
+
+    Value is set using setHorizontalFieldOfView() or setFieldOfView(). These values
+    are always linked by:
+    \code
+    horizontalFieldOfView() = 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ).
+    \endcode */
+    float horizontalFieldOfView() const { return 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ); };
+
+    /*! Returns the Camera aspect ratio defined by screenWidth() / screenHeight().
+
+    When the Camera is attached to a QGLViewer, these values and hence the aspectRatio() are
+    automatically fitted to the viewer's window aspect ratio using setScreenWidthAndHeight(). */
+    float aspectRatio() const { return static_cast<float>(screenWidth_)/static_cast<float>(screenHeight_); };
+    /*! Returns the width (in pixels) of the Camera screen.
+
+    Set using setScreenWidthAndHeight(). This value is automatically fitted to the QGLViewer's
+    window dimensions when the Camera is attached to a QGLViewer. See also QGLWidget::width() */
+    int screenWidth() const { return screenWidth_; };
+    /*! Returns the height (in pixels) of the Camera screen.
+
+    Set using setScreenWidthAndHeight(). This value is automatically fitted to the QGLViewer's
+    window dimensions when the Camera is attached to a QGLViewer. See also QGLWidget::height() */
+    int screenHeight() const { return screenHeight_; };
+    void getViewport(GLint viewport[4]) const;
+    float pixelGLRatio(const Vec& position) const;
+
+    /*! Returns the coefficient which is used to set zNear() when the Camera is inside the sphere
+    defined by sceneCenter() and zClippingCoefficient() * sceneRadius().
+
+    In that case, the zNear() value is set to zNearCoefficient() * zClippingCoefficient() *
+    sceneRadius(). See the zNear() documentation for details.
+
+    Default value is 0.005, which is appropriate for most applications. In case you need a high
+    dynamic ZBuffer precision, you can increase this value (~0.1). A lower value will prevent
+    clipping of very close objects at the expense of a worst Z precision.
+
+    Only meaningful when Camera type is Camera::PERSPECTIVE. */
+    float zNearCoefficient() const { return zNearCoef_; };
+    /*! Returns the coefficient used to position the near and far clipping planes.
+
+    The near (resp. far) clipping plane is positioned at a distance equal to zClippingCoefficient() *
+    sceneRadius() in front of (resp. behind) the sceneCenter(). This garantees an optimal use of
+    the z-buffer range and minimizes aliasing. See the zNear() and zFar() documentations.
+
+    Default value is square root of 3.0 (so that a cube of size sceneRadius() is not clipped).
+
+    However, since the sceneRadius() is used for other purposes (see showEntireScene(), flySpeed(),
+    ...) and you may want to change this value to define more precisely the location of the clipping
+    planes. See also zNearCoefficient().
+
+    For a total control on clipping planes' positions, an other option is to overload the zNear()
+    and zFar() methods. See the <a href="../examples/standardCamera.html">standardCamera example</a>.
+
+    \attention When QGLViewer::cameraPathAreEdited(), this value is set to 5.0 so that the Camera
+    paths are not clipped. The previous zClippingCoefficient() value is restored back when you leave
+    this mode. */
+    float zClippingCoefficient() const { return zClippingCoef_; }
+
+    virtual float zNear() const;
+    virtual float zFar()  const;
+    virtual void getOrthoWidthHeight(GLdouble& halfWidth, GLdouble& halfHeight) const;
+    void getFrustumPlanesCoefficients(GLdouble coef[6][4]) const;
+
+  public:
+    void setType(Type type);
+
+    /*! Sets the vertical fieldOfView() of the Camera (in radians).
+
+    Note that focusDistance() is set to sceneRadius() / tan(fieldOfView()/2) by this method. */
+    void setFieldOfView(float fov) { fieldOfView_ = fov; setFocusDistance(sceneRadius() / tan(fov/2.0)); };
+
+    /*! Sets the horizontalFieldOfView() of the Camera (in radians).
+
+    horizontalFieldOfView() and fieldOfView() are linked by the aspectRatio(). This method actually
+    calls setFieldOfView(( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) )) so that a call to
+    horizontalFieldOfView() returns the expected value. */
+    void setHorizontalFieldOfView(float hfov) { setFieldOfView( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) ); };
+
+    void setFOVToFitScene();
+
+    /*! Defines the Camera aspectRatio().
+
+    This value is actually inferred from the screenWidth() / screenHeight() ratio. You should use
+    setScreenWidthAndHeight() instead.
+
+    This method might however be convenient when the Camera is not associated with a QGLViewer. It
+    actually sets the screenHeight() to 100 and the screenWidth() accordingly. See also
+    setFOVToFitScene().
+
+    \note If you absolutely need an aspectRatio() that does not correspond to your viewer's window
+    dimensions, overload loadProjectionMatrix() or multiply the created GL_PROJECTION matrix by a
+    scaled diagonal matrix in your QGLViewer::draw() method. */
+    void setAspectRatio(float aspect) { setScreenWidthAndHeight(int(100.0*aspect), 100); };
+
+    void setScreenWidthAndHeight(int width, int height);
+    /*! Sets the zNearCoefficient() value. */
+    void setZNearCoefficient(float coef) { zNearCoef_ = coef; };
+    /*! Sets the zClippingCoefficient() value. */
+    void setZClippingCoefficient(float coef) { zClippingCoef_ = coef; }
+    //@}
+
+
+    /*! @name Scene radius and center */
+    //@{
+  public:
+    /*! Returns the radius of the scene observed by the Camera.
+
+    You need to provide such an approximation of the scene dimensions so that the Camera can adapt
+    its zNear() and zFar() values. See the sceneCenter() documentation.
+
+    See also setSceneBoundingBox().
+
+    Note that QGLViewer::sceneRadius() (resp. QGLViewer::setSceneRadius()) simply call this method
+    (resp. setSceneRadius()) on its associated QGLViewer::camera(). */
+    float sceneRadius() const { return sceneRadius_; };
+
+    /*! Returns the position of the scene center, defined in the world coordinate system.
+
+    The scene observed by the Camera should be roughly centered on this position, and included in a
+    sceneRadius() sphere. This approximate description of the scene permits a zNear() and zFar()
+    clipping planes definition, and allows convenient positioning methods such as showEntireScene().
+
+    Default value is (0,0,0) (world origin). Use setSceneCenter() to change it. See also
+    setSceneBoundingBox().
+
+    Note that QGLViewer::sceneCenter() (resp. QGLViewer::setSceneCenter()) simply call this method
+    (resp. setSceneCenter()) on its associated QGLViewer::camera(). */
+    Vec sceneCenter() const { return sceneCenter_; };
+    float distanceToSceneCenter() const;
+
+  public:
+    void setSceneRadius(float radius);
+    void setSceneCenter(const Vec& center);
+    bool setSceneCenterFromPixel(const Point& pixel);
+    void setSceneBoundingBox(const Vec& min, const Vec& max);
+    //@}
+
+
+    /*! @name Revolve Around Point */
+    //@{
+ public:
+    void setRevolveAroundPoint(const Vec& rap);
+    bool setRevolveAroundPointFromPixel(const Point& pixel);
+
+  public:
+    /*! The point the Camera revolves around with the QGLViewer::ROTATE mouse binding. Defined in world coordinate system.
+
+    Default value is the sceneCenter().
+
+    \attention setSceneCenter() changes this value. */
+    Vec revolveAroundPoint() const { return frame()->revolveAroundPoint(); };
+    //@}
+
+
+    /*! @name Associated frame */
+    //@{
+  public:
+    /*! Returns the ManipulatedCameraFrame attached to the Camera.
+
+    This ManipulatedCameraFrame defines its position() and orientation() and can translate mouse
+    events into Camera displacement. Set using setFrame(). */
+    ManipulatedCameraFrame* frame() const { return frame_; };
+  public:
+    void setFrame(ManipulatedCameraFrame* const mcf);
+    //@}
+
+
+    /*! @name KeyFramed paths */
+    //@{
+   public:
+    //KeyFrameInterpolator* keyFrameInterpolator(int i);
+
+public:
+    //void setKeyFrameInterpolator(int i, KeyFrameInterpolator* const kfi);
+
+    //virtual void addKeyFrameToPath(int i);
+    //virtual void playPath(int i);
+    //virtual void deletePath(int i);
+    //virtual void resetPath(int i);
+    //@}
+
+
+    /*! @name OpenGL matrices */
+    //@{
+  public:
+    virtual void loadProjectionMatrix(bool reset=true) const;
+    virtual void loadModelViewMatrix(bool reset=true) const;
+    void computeProjectionMatrix() const;
+    void computeModelViewMatrix() const;
+
+    virtual void loadProjectionMatrixStereo(bool leftBuffer=true) const;
+    virtual void loadModelViewMatrixStereo(bool leftBuffer=true) const;
+
+    void getProjectionMatrix(GLdouble m[16]) const;
+    void getModelViewMatrix(GLdouble m[16]) const;
+	void getModelViewProjectionMatrix(GLdouble m[16]) const;
+
+#ifndef DOXYGEN
+    // Required for windows which otherwise silently fills
+    void getProjectionMatrix(GLfloat m[16]) const;
+    void getModelViewMatrix(GLfloat m[16]) const;
+#endif
+    //@}
+
+    
+    /*! @name Drawing */
+    //@{
+#ifndef DOXYGEN
+    static void drawCamera(float scale=1.0, float aspectRatio=1.33, float fieldOfView=M_PI/4.0);
+#endif
+    virtual void draw(bool drawFarPlane=true, float scale=1.0) const;
+    //@}
+
+    
+    /*! @name World to Camera coordinate systems conversions */
+    //@{
+  public:
+    /*! Returns the Camera frame coordinates of a point \p src defined in world coordinates.
+
+    worldCoordinatesOf() performs the inverse transformation.
+
+    Note that the point coordinates are simply converted in a different coordinate system. They are
+    not projected on screen. Use projectedCoordinatesOf() for that. */
+    Vec cameraCoordinatesOf(const Vec& src) const { return frame()->coordinatesOf(src); };
+    /*! Returns the world coordinates of the point whose position \p src is defined in the Camera
+    coordinate system.
+
+    cameraCoordinatesOf() performs the inverse transformation. */
+    Vec worldCoordinatesOf(const Vec& src) const { return frame()->inverseCoordinatesOf(src); };
+    void getCameraCoordinatesOf(const float src[3], float res[3]) const;
+    void getWorldCoordinatesOf(const float src[3], float res[3]) const;
+    //@}
+
+
+    /*! @name 2D screen to 3D world coordinate systems conversions */
+    //@{
+  public:
+    Vec projectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
+    Vec unprojectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
+    void getProjectedCoordinatesOf(const float src[3], float res[3], const Frame* frame=NULL) const;
+    void getUnprojectedCoordinatesOf(const float src[3], float res[3], const Frame* frame=NULL) const;
+    void convertClickToLine(const Point& pixel, Vec& orig, Vec& dir) const;
+    Vec pointUnderPixel(const Point& pixel, bool& found) const;
+    //@}
+
+
+    /*! @name Fly speed */
+    //@{
+  public:
+    /*! Returns the fly speed of the Camera.
+
+    Simply returns frame()->flySpeed(). See the ManipulatedCameraFrame::flySpeed() documentation.
+    This value is only meaningful when the MouseAction bindings is QGLViewer::MOVE_FORWARD or
+    QGLViewer::MOVE_BACKWARD.
+
+    Set to 0.5% of the sceneRadius() by setSceneRadius(). See also setFlySpeed(). */
+    float flySpeed() const { return frame()->flySpeed(); };
+  public:
+    /*! Sets the Camera flySpeed().
+
+    \attention This value is modified by setSceneRadius(). */
+    void setFlySpeed(float speed) { frame()->setFlySpeed(speed); };
+    //@}
+
+
+    /*! @name Stereo parameters */
+    //@{
+  public:
+    /*! Returns the user's inter-ocular distance (in meters). Default value is 0.062m, which fits most people.
+
+    loadProjectionMatrixStereo() uses this value to define the Camera offset and frustum. See
+    setIODistance(). */
+    float IODistance() const { return IODistance_; };
+
+    /*! Returns the physical distance between the user's eyes and the screen (in meters).
+
+    Default value is 0.5m.
+
+    Used by loadModelViewMatrixStereo() and loadProjectionMatrixStereo() for stereo display. Value
+    is set using setPhysicalDistanceToScreen().
+
+    physicalDistanceToScreen() and focusDistance() represent the same distance. The first one is
+    expressed in physical real world units, while the latter is expressed in OpenGL virtual world
+    units. Use their ratio to convert distances between these worlds.
+
+    Use the following code to detect a reality center configuration (using its screen aspect ratio)
+    and to automatically set physical distances accordingly:
+    \code
+    QDesktopWidget screen;
+    if (fabs((float)screen.width() / (float)screen.height()) > 2.0)
+    {
+      camera()->setPhysicalDistanceToScreen(4.0);
+      camera()->setPhysicalScreenWidth(10.0);
+    }
+    \endcode */
+    float physicalDistanceToScreen() const { return physicalDistanceToScreen_; };
+
+    /*! Returns the physical screen width, in meters. Default value is 0.4m (average monitor).
+
+    Used for stereo display only (see loadModelViewMatrixStereo() and loadProjectionMatrixStereo()).
+    Set using setPhysicalScreenWidth().
+
+    See physicalDistanceToScreen() for reality center automatic configuration. */
+    float physicalScreenWidth() const { return physicalScreenWidth_; };
+
+    /*! Returns the focus distance used by stereo display, expressed in OpenGL units.
+
+    This is the distance in the virtual world between the Camera and the plane where the horizontal
+    stereo parallax is null (the stereo left and right images are superimposed).
+
+    This distance is the virtual world equivalent of the real-world physicalDistanceToScreen().
+
+    \attention This value is modified by QGLViewer::setSceneRadius(), setSceneRadius() and
+    setFieldOfView(). When one of these values is modified, focusDistance() is set to sceneRadius()
+    / tan(fieldOfView()/2), which provides good results. */
+    float focusDistance() const { return focusDistance_; };
+  public:
+    /*! Sets the IODistance(). */
+    void setIODistance(float distance) { IODistance_ = distance; };
+
+    /*! Sets the physicalDistanceToScreen(). */
+    void setPhysicalDistanceToScreen(float distance) { physicalDistanceToScreen_ = distance; };
+
+    /*! Sets the physical screen (monitor or projected wall) width (in meters). */
+    void setPhysicalScreenWidth(float width) { physicalScreenWidth_ = width; };
+
+    /*! Sets the focusDistance(), in OpenGL scene units. */
+    void setFocusDistance(float distance) { focusDistance_ = distance; };
+    //@}
+
+
+  private:
+    // F r a m e
+    ManipulatedCameraFrame* frame_;
+
+    // C a m e r a   p a r a m e t e r s
+    int screenWidth_, screenHeight_;  // size of the window, in pixels
+    float fieldOfView_; // in radians
+    Vec sceneCenter_;
+    float sceneRadius_; // OpenGL units
+    float zNearCoef_;
+    float zClippingCoef_;
+    float orthoCoef_;
+    Type type_; // PERSPECTIVE or ORTHOGRAPHIC
+    mutable GLdouble modelViewMatrix_[16]; // Buffered model view matrix.
+    mutable GLdouble projectionMatrix_[16]; // Buffered projection matrix.
+
+    // S t e r e o   p a r a m e t e r s
+    float IODistance_;		     // inter-ocular distance, in meters
+    float focusDistance_;	     // in scene units
+    float physicalDistanceToScreen_; // in meters
+    float physicalScreenWidth_;	     // in meters
+
+    // P o i n t s   o f   V i e w s   a n d   K e y F r a m e s
+    //map<int, KeyFrameInterpolator*> kfi_;
+    //KeyFrameInterpolator* interpolationKfi_;
+  };
+
+
+#endif // QGLVIEWER_CAMERA_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_config.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_config.h
new file mode 100644
index 00000000000..c2fc1b092e1
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_config.h
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////
+//               libQGLViewer configuration file                 //
+//  Modify these settings according to your local configuration  //
+///////////////////////////////////////////////////////////////////
+
+#ifndef QGLVIEWER_CONFIG_H
+#define QGLVIEWER_CONFIG_H
+
+
+
+
+
+#include <map>
+#include <ostream>
+
+#include <math.h>
+#include <iostream>
+
+using namespace std;
+
+#include "AppGLWidget_point.h"
+
+# ifdef WIN32
+#  include <windows.h>
+# endif
+# ifdef __MACH__
+#  include <OpenGL/gl.h>
+# else
+#  include <GL/gl.h>
+# endif
+
+#ifdef __APPLE_CC__
+	#include <GLUT/glut.h>
+#else
+	#include <GL/glut.h>
+#endif
+
+#ifndef Q_UNUSED
+        #  define Q_UNUSED(x) (void)x;
+#endif
+
+template <typename T>
+inline const T &qMin(const T &a, const T &b) { if (a < b) return a; return b; }
+template <typename T>
+inline const T &qMax(const T &a, const T &b) { if (a < b) return b; return a; }
+template <typename T>
+inline const T &qBound(const T &min, const T &val, const T &max)
+{ return qMax(min, qMin(max, val)); }
+
+#endif // QGLVIEWER_CONFIG_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_constraint.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_constraint.h
new file mode 100644
index 00000000000..4bd629a05de
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_constraint.h
@@ -0,0 +1,341 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_CONSTRAINT_H
+#define QGLVIEWER_CONSTRAINT_H
+
+#include "AppGLWidget_vec.h"
+#include "AppGLWidget_quaternion.h"
+
+//namespace qglviewer {
+  class Frame;
+  class AppGLWidget_Camera;
+
+  /*! \brief An interface class for Frame constraints.
+  \class Constraint constraint.h QGLViewer/constraint.h
+
+  This class defines the interface for the Constraints that can be applied to a Frame to limit its
+  motion. Use Frame::setConstraint() to associate a Constraint to a Frame (default is a \c NULL
+  Frame::constraint()).
+
+  <h3>How does it work ?</h3>
+
+  The Constraint acts as a filter on the translation and rotation Frame increments.
+  constrainTranslation() and constrainRotation() should be overloaded to specify the constraint
+  behavior: the desired displacement is given as a parameter that can optionally be modified.
+
+  Here is how the Frame::translate() and Frame::rotate() methods use the Constraint:
+  \code
+  Frame::translate(Vec& T)
+  {
+    if (constraint())
+      constraint()->constrainTranslation(T, this);
+    t += T;
+  }
+
+  Frame::rotate(Quaternion& Q)
+  {
+    if (constraint())
+      constraint()->constrainRotation(Q, this);
+    q *= Q;
+  }
+  \endcode
+
+  The default behavior of constrainTranslation() and constrainRotation() is empty (meaning no
+  filtering).
+
+  The Frame which uses the Constraint is passed as a parameter to the constrainTranslation() and
+  constrainRotation() methods, so that they can have access to its current state (mainly
+  Frame::position() and Frame::orientation()). It is not \c const for versatility reasons, but
+  directly modifying it should be avoided.
+
+  \attention Frame::setTranslation(), Frame::setRotation() and similar methods will actually indeed
+  set the frame position and orientation, without taking the constraint into account. Use the \e
+  WithConstraint versions of these methods to enforce the Constraint.
+
+  <h3>Implemented Constraints</h3>
+
+  Classical axial and plane Constraints are provided for convenience: see the LocalConstraint,
+  WorldConstraint and CameraConstraint classes' documentations.
+
+  Try the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
+  href="../examples/constrainedCamera.html">constrainedCamera</a> examples for an illustration.
+
+  <h3>Creating new Constraints</h3>
+
+  The implementation of a new Constraint class simply consists in overloading the filtering methods:
+  \code
+  // This Constraint enforces that the Frame cannot have a negative z world coordinate.
+  class myConstraint : public Constraint
+  {
+  public:
+    virtual void constrainTranslation(Vec& t, Frame * const fr)
+      {
+        // Express t in the world coordinate system.
+        const Vec tWorld = fr->inverseTransformOf(t);
+	if (fr->position().z + tWorld.z < 0.0) // check the new fr z coordinate
+	  t.z = fr->transformOf(-fr->position().z); // t.z is clamped so that next z position is 0.0
+      }
+  };
+  \endcode
+
+  Note that the translation (resp. rotation) parameter passed to constrainTranslation() (resp.
+  constrainRotation()) is expressed in the \e local Frame coordinate system. Here, we use the
+  Frame::transformOf() and Frame::inverseTransformOf() method to convert it to and from the world
+  coordinate system.
+
+  Combined constraints can easily be achieved by creating a new class that applies the different
+  constraint filters:
+  \code
+  myConstraint::constrainTranslation(Vec& v, Frame* const fr)
+  {
+    constraint1->constrainTranslation(v, fr);
+    constraint2->constrainTranslation(v, fr);
+    // and so on, with possible branches, tests, loops...
+  }
+  \endcode
+  */
+  class Constraint
+  {
+  public:
+    /*! Virtual destructor. Empty. */
+    virtual ~Constraint() {};
+
+    /*! Filters the translation applied to the \p frame. This default implementation is empty (no
+      filtering).
+
+    Overload this method in your own Constraint class to define a new translation constraint. \p
+    frame is the Frame to which is applied the translation. It is not defined \c const, but you
+    should refrain from directly changing its value in the constraint. Use its Frame::position() and
+    update the \p translation accordingly instead.
+
+    \p translation is expressed in local frame coordinate system. Use Frame::inverseTransformOf() to
+    express it in the world coordinate system if needed. */
+    virtual void constrainTranslation(Vec& translation, Frame* const frame) { Q_UNUSED(translation); Q_UNUSED(frame); };
+    /*! Filters the rotation applied to the \p frame. This default implementation is empty (no
+      filtering).
+
+    Overload this method in your own Constraint class to define a new rotation constraint. See
+    constrainTranslation() for details.
+
+    Use Frame::inverseTransformOf() on the \p rotation Quaternion::axis() to express \p rotation in
+    the world coordinate system if needed. */
+    virtual void constrainRotation(Quaternion& rotation, Frame* const frame) { Q_UNUSED(rotation); Q_UNUSED(frame); };
+  };
+
+  /*!
+   \brief An abstract class for Frame Constraints defined by an axis or a plane.
+   \class AxisPlaneConstraint constraint.h QGLViewer/constraint.h
+
+   AxisPlaneConstraint is an interface for (translation and/or rotation) Constraint that are defined
+   by a direction. translationConstraintType() and rotationConstraintType() define how this
+   direction should be interpreted: as an axis (AxisPlaneConstraint::AXIS) or as a plane normal
+   (AxisPlaneConstraint::PLANE). See the Type() documentation for details.
+
+   The three implementations of this class: LocalConstraint, WorldConstraint and CameraConstraint
+   differ by the coordinate system in which this direction is expressed.
+
+   Different implementations of this class are illustrated in the
+   <a href="../examples/constrainedCamera.html">contrainedCamera</a> and
+   <a href="../examples/constrainedFrame.html">constrainedFrame</a> examples.
+
+   \attention When applied, the rotational Constraint may not intuitively follow the mouseQU
+   displacement. A solution would be to directly measure the rotation angle in screen coordinates,
+   but that would imply to know the QGLViewer::camera(), so that we can compute the projected
+   coordinates of the rotation center (as is done with the QGLViewer::SCREEN_ROTATE binding).
+   However, adding an extra pointer to the QGLViewer::camera() in all the AxisPlaneConstraint
+   derived classes (which the user would have to update in a multi-viewer application) was judged as
+   an overkill. */
+  class AxisPlaneConstraint : public Constraint
+  {
+  public:
+    AxisPlaneConstraint();
+    /*! Virtual destructor. Empty. */
+    virtual ~AxisPlaneConstraint() {};
+
+    /*! Type lists the different types of translation and rotation constraints that are available.
+
+    It specifies the meaning of the constraint direction (see translationConstraintDirection() and
+    rotationConstraintDirection()): as an axis direction (AxisPlaneConstraint::AXIS) or a plane
+    normal (AxisPlaneConstraint::PLANE). AxisPlaneConstraint::FREE means no constraint while
+    AxisPlaneConstraint::FORBIDDEN completely forbids the translation and/or the rotation.
+
+    See translationConstraintType() and rotationConstraintType().
+
+    \attention The AxisPlaneConstraint::PLANE Type is not valid for rotational constraint.
+
+    New derived classes can use their own extended enum for specific constraints:
+    \code
+    class MyAxisPlaneConstraint : public AxisPlaneConstraint
+    {
+    public:
+      enum MyType { FREE, AXIS, PLANE, FORBIDDEN, CUSTOM };
+      virtual void constrainTranslation(Vec &translation, Frame *const frame)
+      {
+        // translationConstraintType() is simply an int. CUSTOM Type is handled seamlessly.
+        switch (translationConstraintType())
+	{
+	case MyAxisPlaneConstraint::FREE: ... break;
+	case MyAxisPlaneConstraint::CUSTOM: ... break;
+	}
+      };
+
+      MyAxisPlaneConstraint* c = new MyAxisPlaneConstraint();
+      // Note the Type conversion
+      c->setTranslationConstraintType(AxisPlaneConstraint::Type(MyAxisPlaneConstraint::CUSTOM));
+    };
+    \endcode */
+    enum Type { FREE, AXIS, PLANE, FORBIDDEN };
+
+    /*! @name Translation constraint */
+    //@{
+    /*! Overloading of Constraint::constrainTranslation(). Empty */
+    virtual void constrainTranslation(Vec& translation, Frame* const frame) { Q_UNUSED(translation); Q_UNUSED(frame); };
+
+    void setTranslationConstraint(Type type, const Vec& direction);
+    /*! Sets the Type() of the translationConstraintType(). Default is AxisPlaneConstraint::FREE. */
+    void setTranslationConstraintType(Type type) { translationConstraintType_ = type; };
+    void setTranslationConstraintDirection(const Vec& direction);
+
+    /*! Returns the translation constraint Type().
+
+    Depending on this value, the Frame will freely translate (AxisPlaneConstraint::FREE), will only
+    be able to translate along an axis direction (AxisPlaneConstraint::AXIS), will be forced to stay
+    into a plane (AxisPlaneConstraint::PLANE) or will not able to translate at all
+    (AxisPlaneConstraint::FORBIDDEN).
+
+    Use Frame::setPosition() to define the position of the constrained Frame before it gets
+    constrained. */
+    Type translationConstraintType() const { return translationConstraintType_; };
+    /*! Returns the direction used by the translation constraint.
+
+    It represents the axis direction (AxisPlaneConstraint::AXIS) or the plane normal
+    (AxisPlaneConstraint::PLANE) depending on the translationConstraintType(). It is undefined for
+    AxisPlaneConstraint::FREE or AxisPlaneConstraint::FORBIDDEN.
+
+    The AxisPlaneConstraint derived classes express this direction in different coordinate system
+    (camera for CameraConstraint, local for LocalConstraint, and world for WorldConstraint). This
+    value can be modified with setTranslationConstraintDirection(). */
+    Vec translationConstraintDirection() const { return translationConstraintDir_; };
+    //@}
+
+    /*! @name Rotation constraint */
+    //@{
+    /*! Overloading of Constraint::constrainRotation(). Empty. */
+    virtual void constrainRotation(Quaternion& rotation, Frame* const frame) { Q_UNUSED(rotation); Q_UNUSED(frame); };
+
+    void setRotationConstraint(Type type, const Vec& direction);
+    void setRotationConstraintType(Type type);
+    void setRotationConstraintDirection(const Vec& direction);
+
+    /*! Returns the rotation constraint Type(). */
+    Type rotationConstraintType() const { return rotationConstraintType_; };
+    /*! Returns the axis direction used by the rotation constraint.
+
+    This direction is defined only when rotationConstraintType() is AxisPlaneConstraint::AXIS.
+
+    The AxisPlaneConstraint derived classes express this direction in different coordinate system
+    (camera for CameraConstraint, local for LocalConstraint, and world for WorldConstraint). This
+    value can be modified with setRotationConstraintDirection(). */
+    Vec rotationConstraintDirection() const { return rotationConstraintDir_; };
+    //@}
+
+  private:
+    // int and not Type to allow for overloading and new types definition.
+    Type translationConstraintType_;
+    Type rotationConstraintType_;
+
+    Vec translationConstraintDir_;
+    Vec rotationConstraintDir_;
+  };
+
+
+  /*! \brief An AxisPlaneConstraint defined in the Frame local coordinate system.
+  \class LocalConstraint constraint.h QGLViewer/constraint.h
+
+  The translationConstraintDirection() and rotationConstraintDirection() are expressed in the Frame
+  local coordinate system (see Frame::referenceFrame()).
+
+  See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> example for an illustration. */
+  class LocalConstraint : public AxisPlaneConstraint
+  {
+  public:
+    /*! Virtual destructor. Empty. */
+    virtual ~LocalConstraint() {};
+
+    virtual void constrainTranslation(Vec&     translation, Frame* const frame);
+    virtual void constrainRotation   (Quaternion& rotation, Frame* const frame);
+  };
+
+
+
+  /*! \brief An AxisPlaneConstraint defined in the world coordinate system.
+    \class WorldConstraint constraint.h QGLViewer/constraint.h
+
+  The translationConstraintDirection() and rotationConstraintDirection() are expressed in world
+  coordinate system.
+
+  See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
+  href="../examples/multiView.html">multiView</a> examples for an illustration. */
+  class WorldConstraint : public AxisPlaneConstraint
+  {
+  public:
+    /*! Virtual destructor. Empty. */
+    virtual ~WorldConstraint() {};
+
+    virtual void constrainTranslation(Vec&     translation, Frame* const frame);
+    virtual void constrainRotation   (Quaternion& rotation, Frame* const frame);
+  };
+
+
+
+  /*! \brief An AxisPlaneConstraint defined in the camera coordinate system.
+  \class CameraConstraint constraint.h QGLViewer/constraint.h
+
+  The translationConstraintDirection() and rotationConstraintDirection() are expressed in the
+  associated camera() coordinate system.
+
+  See the <a href="../examples/constrainedFrame.html">constrainedFrame</a> and <a
+  href="../examples/constrainedCamera.html">constrainedCamera</a> examples for an illustration. */
+  class CameraConstraint : public AxisPlaneConstraint
+  {
+  public:
+    explicit CameraConstraint(const AppGLWidget_Camera* const camera);
+    /*! Virtual destructor. Empty. */
+    virtual ~CameraConstraint() {};
+
+    virtual void constrainTranslation(Vec&     translation, Frame* const frame);
+    virtual void constrainRotation   (Quaternion& rotation, Frame* const frame);
+
+    /*! Returns the associated Camera. Set using the CameraConstraint constructor. */
+    const AppGLWidget_Camera* camera() const { return camera_; };
+
+  private:
+    const AppGLWidget_Camera* const camera_;
+  };
+
+//} // namespace qglviewer
+
+#endif // QGLVIEWER_CONSTRAINT_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.cpp
new file mode 100644
index 00000000000..8fb17a7c1c6
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.cpp
@@ -0,0 +1,1070 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_frame.h"
+#include <math.h>
+
+//using namespace qglviewer;
+using namespace std;
+
+
+/*! Creates a default Frame.
+
+  Its position() is (0,0,0) and it has an identity orientation() Quaternion. The referenceFrame()
+  and the constraint() are \c NULL. */
+Frame::Frame()
+  : constraint_(NULL), referenceFrame_(NULL)
+{}
+
+/*! Creates a Frame with a position() and an orientation().
+
+ See the Vec and Quaternion documentations for convenient constructors and methods.
+
+ The Frame is defined in the world coordinate system (its referenceFrame() is \c NULL). It
+ has a \c NULL associated constraint(). */
+Frame::Frame(const Vec& position, const Quaternion& orientation)
+  : t_(position), q_(orientation), constraint_(NULL), referenceFrame_(NULL)
+{}
+
+/*! Equal operator.
+
+  The referenceFrame() and constraint() pointers are copied.
+
+  \attention Signal and slot connections are not copied. */
+Frame& Frame::operator=(const Frame& frame)
+{
+  // Automatic compiler generated version would not emit the modified signals as is done in
+  // setTranslationAndRotation.
+  setTranslationAndRotation(frame.translation(), frame.rotation());
+  setConstraint(frame.constraint());
+  setReferenceFrame(frame.referenceFrame());
+  return *this;
+}
+
+/*! Copy constructor.
+
+  The translation() and rotation() as well as constraint() and referenceFrame() pointers are
+  copied. */
+Frame::Frame(const Frame& frame)
+{
+  (*this) = frame;
+}
+
+/////////////////////////////// MATRICES //////////////////////////////////////
+
+/*! Returns the 4x4 OpenGL transformation matrix represented by the Frame.
+
+  This method should be used in conjunction with \c glMultMatrixd() to modify the OpenGL modelview
+  matrix from a Frame hierarchy. With this Frame hierarchy:
+  \code
+  Frame* body     = new Frame();
+  Frame* leftArm  = new Frame();
+  Frame* rightArm = new Frame();
+  leftArm->setReferenceFrame(body);
+  rightArm->setReferenceFrame(body);
+  \endcode
+
+  The associated OpenGL drawing code should look like:
+  \code
+  void Viewer::draw()
+  {
+    glPushMatrix();
+    glMultMatrixd(body->matrix());
+    drawBody();
+
+    glPushMatrix();
+    glMultMatrixd(leftArm->matrix());
+    drawArm();
+    glPopMatrix();
+
+    glPushMatrix();
+    glMultMatrixd(rightArm->matrix());
+    drawArm();
+    glPopMatrix();
+
+    glPopMatrix();
+  }
+  \endcode
+  Note the use of nested \c glPushMatrix() and \c glPopMatrix() blocks to represent the frame hierarchy: \c
+  leftArm and \c rightArm are both correctly drawn with respect to the \c body coordinate system.
+
+  This matrix only represents the local Frame transformation (i.e. with respect to the
+  referenceFrame()). Use worldMatrix() to get the full Frame transformation matrix (i.e. from the
+  world to the Frame coordinate system). These two match when the referenceFrame() is \c NULL.
+
+  The result is only valid until the next call to matrix(), getMatrix(), worldMatrix() or
+  getWorldMatrix(). Use it immediately (as above) or use getMatrix() instead.
+
+  \attention The OpenGL format of the result is the transpose of the actual mathematical European
+  representation (translation is on the last \e line instead of the last \e column).
+
+  \note The scaling factor of the 4x4 matrix is 1.0. */
+const GLdouble* Frame::matrix() const
+{
+  static GLdouble m[4][4];
+  getMatrix(m);
+  return (const GLdouble*)(m);
+}
+
+/*! \c GLdouble[4][4] version of matrix(). See also getWorldMatrix() and matrix(). */
+void Frame::getMatrix(GLdouble m[4][4]) const
+{
+  q_.getMatrix(m);
+
+  m[3][0] = t_[0];
+  m[3][1] = t_[1];
+  m[3][2] = t_[2];
+}
+
+/*! \c GLdouble[16] version of matrix(). See also getWorldMatrix() and matrix(). */
+void Frame::getMatrix(GLdouble m[16]) const
+{
+  q_.getMatrix(m);
+
+  m[12] = t_[0];
+  m[13] = t_[1];
+  m[14] = t_[2];
+}
+
+/*! Returns a Frame representing the inverse of the Frame space transformation.
+
+  The rotation() of the new Frame is the Quaternion::inverse() of the original rotation.
+  Its translation() is the negated inverse rotated image of the original translation.
+
+  If a Frame is considered as a space rigid transformation (translation and rotation), the inverse()
+  Frame performs the inverse transformation.
+
+  Only the local Frame transformation (i.e. defined with respect to the referenceFrame()) is inverted.
+  Use worldInverse() for a global inverse.
+
+  The resulting Frame has the same referenceFrame() as the Frame and a \c NULL constraint().
+
+  \note The scaling factor of the 4x4 matrix is 1.0. */
+Frame Frame::inverse() const
+{
+  Frame fr(-(q_.inverseRotate(t_)), q_.inverse());
+  fr.setReferenceFrame(referenceFrame());
+  return fr;
+}
+
+/*! Returns the 4x4 OpenGL transformation matrix represented by the Frame.
+
+  This method should be used in conjunction with \c glMultMatrixd() to modify
+  the OpenGL modelview matrix from a Frame:
+  \code
+  // The modelview here corresponds to the world coordinate system.
+  Frame fr(pos, Quaternion(from, to));
+  glPushMatrix();
+  glMultMatrixd(fr.worldMatrix());
+  // draw object in the fr coordinate system.
+  glPopMatrix();
+  \endcode
+
+  This matrix represents the global Frame transformation: the entire referenceFrame() hierarchy is
+  taken into account to define the Frame transformation from the world coordinate system. Use
+  matrix() to get the local Frame transformation matrix (i.e. defined with respect to the
+  referenceFrame()). These two match when the referenceFrame() is \c NULL.
+
+  The OpenGL format of the result is the transpose of the actual mathematical European
+  representation (translation is on the last \e line instead of the last \e column).
+
+  \attention The result is only valid until the next call to matrix(), getMatrix(), worldMatrix() or
+  getWorldMatrix(). Use it immediately (as above) or use getWorldMatrix() instead.
+
+  \note The scaling factor of the 4x4 matrix is 1.0. */
+const GLdouble* Frame::worldMatrix() const
+{
+  // This test is done for efficiency reasons (creates lots of temp objects otherwise).
+  if (referenceFrame())
+  {
+    static Frame fr;
+    fr.setTranslation(position());
+    fr.setRotation(orientation());
+    return fr.matrix();
+  }
+  else
+    return matrix();
+}
+
+/*! float[4][4] parameter version of worldMatrix(). See also getMatrix() and matrix(). */
+void Frame::getWorldMatrix(GLdouble m[4][4]) const
+{
+  const GLdouble* mat = worldMatrix();
+  for (int i=0; i<4; ++i)
+    for (int j=0; j<4; ++j)
+      m[i][j] = mat[i*4+j];
+}
+
+/*! float[16] parameter version of worldMatrix(). See also getMatrix() and matrix(). */
+void Frame::getWorldMatrix(GLdouble m[16]) const
+{
+  const GLdouble* mat = worldMatrix();
+  for (int i=0; i<16; ++i)
+      m[i] = mat[i];
+}
+
+/*! This is an overloaded method provided for convenience. Same as setFromMatrix(). */
+void Frame::setFromMatrix(const GLdouble m[4][4])
+{
+  if (fabs(m[3][3]) < 1E-8)
+    {
+      cout << "Frame::setFromMatrix: Null homogeneous coefficient" << endl;
+      return;
+    }
+
+  double rot[3][3];
+  for (int i=0; i<3; ++i)
+    {
+      t_[i] = m[3][i] / m[3][3];
+      for (int j=0; j<3; ++j)
+	// Beware of the transposition (OpenGL to European math)
+	rot[i][j] = m[j][i] / m[3][3];
+    }
+  q_.setFromRotationMatrix(rot);
+}
+
+/*! Sets the Frame from an OpenGL matrix representation (rotation in the upper left 3x3 matrix and
+ translation on the last line).
+
+ Hence, if a code fragment looks like:
+ \code
+ GLdouble m[16]={...};
+ glMultMatrixd(m);
+ \endcode
+ It is equivalent to write:
+ \code
+ Frame fr;
+ fr.setFromMatrix(m);
+ glMultMatrixd(fr.matrix());
+ \endcode
+
+ Using this conversion, you can benefit from the powerful Frame transformation methods to translate
+ points and vectors to and from the Frame coordinate system to any other Frame coordinate system
+ (including the world coordinate system). See coordinatesOf() and transformOf().
+
+ Emits the modified() signal. See also matrix(), getMatrix() and
+ Quaternion::setFromRotationMatrix().
+
+ \attention A Frame does not contain a scale factor. The possible scaling in \p m will not be
+ converted into the Frame by this method. */
+void Frame::setFromMatrix(const GLdouble m[16])
+{
+  GLdouble mat[4][4];
+  for (int i=0; i<4; ++i)
+    for (int j=0; j<4; ++j)
+      mat[i][j] = m[i*4+j];
+  setFromMatrix(mat);
+}
+
+//////////////////// SET AND GET LOCAL TRANSLATION AND ROTATION ///////////////////////////////
+
+
+/*! Same as setTranslation(), but with \p float parameters. */
+void Frame::setTranslation(float x, float y, float z)
+{
+  setTranslation(Vec(x, y, z));
+}
+
+/*! Fill \c x, \c y and \c z with the translation() of the Frame. */
+void Frame::getTranslation(float& x, float& y, float& z) const
+{
+  const Vec t = translation();
+  x = t[0];
+  y = t[1];
+  z = t[2];
+}
+
+/*! Same as setRotation() but with \c float Quaternion parameters. */
+void Frame::setRotation(double q0, double q1, double q2, double q3)
+{
+  setRotation(Quaternion(q0, q1, q2, q3));
+}
+
+/*! The \p q are set to the rotation() of the Frame.
+
+See Quaternion::Quaternion(double, double, double, double) for details on \c q. */
+void Frame::getRotation(double& q0, double& q1, double& q2, double& q3) const
+{
+  const Quaternion q = rotation();
+  q0 = q[0];
+  q1 = q[1];
+  q2 = q[2];
+  q3 = q[3];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*! Translates the Frame of \p t (defined in the Frame coordinate system).
+
+  The translation actually applied to the Frame may differ from \p t since it can be filtered by the
+  constraint(). Use translate(Vec&) or setTranslationWithConstraint() to retrieve the filtered
+  translation value. Use setTranslation() to directly translate the Frame without taking the
+  constraint() into account.
+
+  See also rotate(const Quaternion&). Emits the modified() signal. */
+void Frame::translate(const Vec& t)
+{
+  Vec tbis = t;
+  translate(tbis);
+}
+
+/*! Same as translate(const Vec&) but \p t may be modified to satisfy the translation constraint().
+  Its new value corresponds to the translation that has actually been applied to the Frame. */
+void Frame::translate(Vec& t)
+{
+  if (constraint())
+    constraint()->constrainTranslation(t, this);
+  t_ += t;
+}
+
+/*! Same as translate(const Vec&) but with \c float parameters. */
+void Frame::translate(float x, float y, float z)
+{
+  Vec t(x,y,z);
+  translate(t);
+}
+
+/*! Same as translate(Vec&) but with \c float parameters. */
+void Frame::translate(float& x, float& y, float& z)
+{
+  Vec t(x,y,z);
+  translate(t);
+  x = t[0];
+  y = t[1];
+  z = t[2];
+}
+
+/*! Rotates the Frame by \p q (defined in the Frame coordinate system): R = R*q.
+
+  The rotation actually applied to the Frame may differ from \p q since it can be filtered by the
+  constraint(). Use rotate(Quaternion&) or setRotationWithConstraint() to retrieve the filtered
+  rotation value. Use setRotation() to directly rotate the Frame without taking the constraint()
+  into account.
+
+  See also translate(const Vec&). Emits the modified() signal. */
+void Frame::rotate(const Quaternion& q)
+{
+  Quaternion qbis = q;
+  rotate(qbis);
+}
+
+/*! Same as rotate(const Quaternion&) but \p q may be modified to satisfy the rotation constraint().
+  Its new value corresponds to the rotation that has actually been applied to the Frame. */
+void Frame::rotate(Quaternion& q)
+{
+  if (constraint())
+    constraint()->constrainRotation(q, this);
+  q_ *= q;
+  q_.normalize(); // Prevents numerical drift
+}
+
+/*! Same as rotate(Quaternion&) but with \c float Quaternion parameters. */
+void Frame::rotate(double& q0, double& q1, double& q2, double& q3)
+{
+  Quaternion q(q0,q1,q2,q3);
+  rotate(q);
+  q0 = q[0];
+  q1 = q[1];
+  q2 = q[2];
+  q3 = q[3];
+}
+
+/*! Same as rotate(const Quaternion&) but with \c float Quaternion parameters. */
+void Frame::rotate(double q0, double q1, double q2, double q3)
+{
+  Quaternion q(q0,q1,q2,q3);
+  rotate(q);
+}
+
+/*! Makes the Frame rotate() by \p rotation around \p point.
+
+  \p point is defined in the world coordinate system, while the \p rotation axis is defined in the
+  Frame coordinate system.
+
+  If the Frame has a constraint(), \p rotation is first constrained using
+  Constraint::constrainRotation(). The translation which results from the filtered rotation around
+  \p point is then computed and filtered using Constraint::constrainTranslation(). The new \p
+  rotation value corresponds to the rotation that has actually been applied to the Frame.
+
+  Emits the modified() signal. */
+void Frame::rotateAroundPoint(Quaternion& rotation, const Vec& point)
+{
+  if (constraint())
+    constraint()->constrainRotation(rotation, this);
+  q_ *= rotation;
+  q_.normalize(); // Prevents numerical drift
+  Vec trans = point + Quaternion(inverseTransformOf(rotation.axis()), rotation.angle()).rotate(position()-point) - t_;
+  if (constraint())
+    constraint()->constrainTranslation(trans, this);
+  t_ += trans;
+}
+
+/*! Same as rotateAroundPoint(), but with a \c const \p rotation Quaternion. Note that the actual
+  rotation may differ since it can be filtered by the constraint(). */
+void Frame::rotateAroundPoint(const Quaternion& rotation, const Vec& point)
+{
+  Quaternion rot = rotation;
+  rotateAroundPoint(rot, point);
+}
+
+//////////////////// SET AND GET WORLD POSITION AND ORIENTATION ///////////////////////////////
+
+/*! Sets the position() of the Frame, defined in the world coordinate system. Emits the modified()
+  signal.
+
+Use setTranslation() to define the \e local frame translation (with respect to the
+referenceFrame()). The potential constraint() of the Frame is not taken into account, use
+setPositionWithConstraint() instead. */
+void Frame::setPosition(const Vec& position)
+{
+  if (referenceFrame())
+    setTranslation(referenceFrame()->coordinatesOf(position));
+  else
+    setTranslation(position);
+}
+
+/*! Same as setPosition(), but with \c float parameters. */
+void Frame::setPosition(float x, float y, float z)
+{
+  setPosition(Vec(x, y, z));
+}
+
+/*! Same as successive calls to setPosition() and then setOrientation().
+
+Only one modified() signal is emitted, which is convenient if this signal is connected to a
+QGLViewer::updateGL() slot. See also setTranslationAndRotation() and
+setPositionAndOrientationWithConstraint(). */
+void Frame::setPositionAndOrientation(const Vec& position, const Quaternion& orientation)
+{
+  if (referenceFrame())
+    {
+      t_ = referenceFrame()->coordinatesOf(position);
+      q_ = referenceFrame()->orientation().inverse() * orientation;
+    }
+  else
+    {
+      t_ = position;
+      q_ = orientation;
+    }
+}
+
+
+/*! Same as successive calls to setTranslation() and then setRotation().
+
+Only one modified() signal is emitted, which is convenient if this signal is connected to a
+QGLViewer::updateGL() slot. See also setPositionAndOrientation() and
+setTranslationAndRotationWithConstraint(). */
+void Frame::setTranslationAndRotation(const Vec& translation, const Quaternion& rotation)
+{
+  t_ = translation;
+  q_ = rotation;
+}
+
+
+/*! \p x, \p y and \p z are set to the position() of the Frame. */
+void Frame::getPosition(float& x, float& y, float& z) const
+{
+  Vec p = position();
+  x = p.x;
+  y = p.y;
+  z = p.z;
+}
+
+/*! Sets the orientation() of the Frame, defined in the world coordinate system. Emits the modified() signal.
+
+Use setRotation() to define the \e local frame rotation (with respect to the referenceFrame()). The
+potential constraint() of the Frame is not taken into account, use setOrientationWithConstraint()
+instead. */
+void Frame::setOrientation(const Quaternion& orientation)
+{
+  if (referenceFrame())
+    setRotation(referenceFrame()->orientation().inverse() * orientation);
+  else
+    setRotation(orientation);
+}
+
+/*! Same as setOrientation(), but with \c float parameters. */
+void Frame::setOrientation(double q0, double q1, double q2, double q3)
+{
+  setOrientation(Quaternion(q0, q1, q2, q3));
+}
+
+/*! Get the current orientation of the frame (same as orientation()).
+  Parameters are the orientation Quaternion values.
+  See also setOrientation(). */
+
+/*! The \p q are set to the orientation() of the Frame.
+
+See Quaternion::Quaternion(double, double, double, double) for details on \c q. */
+void Frame::getOrientation(double& q0, double& q1, double& q2, double& q3) const
+{
+  Quaternion o = orientation();
+  q0 = o[0];
+  q1 = o[1];
+  q2 = o[2];
+  q3 = o[3];
+}
+
+/*! Returns the orientation of the Frame, defined in the world coordinate system. See also
+  position(), setOrientation() and rotation(). */
+Quaternion Frame::orientation() const
+{
+  Quaternion res = rotation();
+  const Frame* fr = referenceFrame();
+  while (fr != NULL)
+    {
+      res = fr->rotation() * res;
+      fr  = fr->referenceFrame();
+    }
+  return res;
+}
+
+
+////////////////////// C o n s t r a i n t   V e r s i o n s  //////////////////////////
+
+/*! Same as setTranslation(), but \p translation is modified so that the potential constraint() of the
+  Frame is satisfied.
+
+  Emits the modified() signal. See also setRotationWithConstraint() and setPositionWithConstraint(). */
+void Frame::setTranslationWithConstraint(Vec& translation)
+{
+  Vec deltaT = translation - this->translation();
+  if (constraint())
+    constraint()->constrainTranslation(deltaT, this);
+
+  setTranslation(this->translation() + deltaT);
+  translation = this->translation();
+}
+
+/*! Same as setRotation(), but \p rotation is modified so that the potential constraint() of the
+  Frame is satisfied.
+
+  Emits the modified() signal. See also setTranslationWithConstraint() and setOrientationWithConstraint(). */
+void Frame::setRotationWithConstraint(Quaternion& rotation)
+{
+  Quaternion deltaQ = this->rotation().inverse() * rotation;
+  if (constraint())
+    constraint()->constrainRotation(deltaQ, this);
+
+  // Prevent numerical drift
+  deltaQ.normalize();
+
+  setRotation(this->rotation() * deltaQ);
+  q_.normalize();
+  rotation = this->rotation();
+}
+
+/*! Same as setTranslationAndRotation(), but \p translation and \p orientation are modified to
+  satisfy the constraint(). Emits the modified() signal. */
+void Frame::setTranslationAndRotationWithConstraint(Vec& translation, Quaternion& rotation)
+{
+  Vec deltaT = translation - this->translation();
+  Quaternion deltaQ = this->rotation().inverse() * rotation;
+
+  if (constraint())
+    {
+      constraint()->constrainTranslation(deltaT, this);
+      constraint()->constrainRotation(deltaQ, this);
+    }
+
+  // Prevent numerical drift
+  deltaQ.normalize();
+
+  t_ += deltaT;
+  q_ *= deltaQ;
+  q_.normalize();
+
+  translation = this->translation();
+  rotation = this->rotation();
+
+}
+
+/*! Same as setPosition(), but \p position is modified so that the potential constraint() of the
+  Frame is satisfied. See also setOrientationWithConstraint() and setTranslationWithConstraint(). */
+void Frame::setPositionWithConstraint(Vec& position)
+{
+  if (referenceFrame())
+    position = referenceFrame()->coordinatesOf(position);
+
+  setTranslationWithConstraint(position);
+}
+
+/*! Same as setOrientation(), but \p orientation is modified so that the potential constraint() of the Frame
+  is satisfied. See also setPositionWithConstraint() and setRotationWithConstraint(). */
+void Frame::setOrientationWithConstraint(Quaternion& orientation)
+{
+  if (referenceFrame())
+    orientation = referenceFrame()->orientation().inverse() * orientation;
+
+  setRotationWithConstraint(orientation);
+}
+
+/*! Same as setPositionAndOrientation() but \p position and \p orientation are modified to satisfy
+the constraint. Emits the modified() signal. */
+void Frame::setPositionAndOrientationWithConstraint(Vec& position, Quaternion& orientation)
+{
+  if (referenceFrame())
+    {
+      position = referenceFrame()->coordinatesOf(position);
+      orientation = referenceFrame()->orientation().inverse() * orientation;
+    }
+  setTranslationAndRotationWithConstraint(position, orientation);
+}
+
+
+///////////////////////////// REFERENCE FRAMES ///////////////////////////////////////
+
+/*! Sets the referenceFrame() of the Frame.
+
+The Frame translation() and rotation() are then defined in the referenceFrame() coordinate system.
+Use position() and orientation() to express these in the world coordinate system.
+
+Emits the modified() signal if \p refFrame differs from the current referenceFrame().
+
+Using this method, you can create a hierarchy of Frames. This hierarchy needs to be a tree, which
+root is the world coordinate system (i.e. a \c NULL referenceFrame()). A warning is printed and no
+action is performed if setting \p refFrame as the referenceFrame() would create a loop in the Frame
+hierarchy (see settingAsReferenceFrameWillCreateALoop()). */
+void Frame::setReferenceFrame(const Frame* const refFrame)
+{
+  if (settingAsReferenceFrameWillCreateALoop(refFrame))
+    cout << "Frame::setReferenceFrame would create a loop in Frame hierarchy" << endl;
+  else
+    {
+      //bool identical = (referenceFrame_ == refFrame);
+      referenceFrame_ = refFrame;
+    }
+}
+
+/*! Returns \c true if setting \p frame as the Frame's referenceFrame() would create a loop in the
+  Frame hierarchy. */
+bool Frame::settingAsReferenceFrameWillCreateALoop(const Frame* const frame)
+{
+  const Frame* f = frame;
+  while (f != NULL)
+    {
+      if (f == this)
+	return true;
+      f = f->referenceFrame();
+    }
+  return false;
+}
+
+///////////////////////// FRAME TRANSFORMATIONS OF 3D POINTS //////////////////////////////
+
+/*! Returns the Frame coordinates of a point \p src defined in the world coordinate system (converts
+ from world to Frame).
+
+ inverseCoordinatesOf() performs the inverse convertion. transformOf() converts 3D vectors instead
+ of 3D coordinates.
+
+ See the <a href="../examples/frameTransform.html">frameTransform example</a> for an
+ illustration. */
+Vec Frame::coordinatesOf(const Vec& src) const
+{
+  if (referenceFrame())
+    return localCoordinatesOf(referenceFrame()->coordinatesOf(src));
+  else
+    return localCoordinatesOf(src);
+}
+
+/*! Returns the world coordinates of the point whose position in the Frame coordinate system is \p
+  src (converts from Frame to world).
+
+  coordinatesOf() performs the inverse convertion. Use inverseTransformOf() to transform 3D vectors
+  instead of 3D coordinates. */
+Vec Frame::inverseCoordinatesOf(const Vec& src) const
+{
+  const Frame* fr = this;
+  Vec res = src;
+  while (fr != NULL)
+    {
+      res = fr->localInverseCoordinatesOf(res);
+      fr  = fr->referenceFrame();
+    }
+  return res;
+}
+
+/*! Returns the Frame coordinates of a point \p src defined in the referenceFrame() coordinate
+  system (converts from referenceFrame() to Frame).
+
+  localInverseCoordinatesOf() performs the inverse convertion. See also localTransformOf(). */
+Vec Frame::localCoordinatesOf(const Vec& src) const
+{
+  return rotation().inverseRotate(src - translation());
+}
+
+/*! Returns the referenceFrame() coordinates of a point \p src defined in the Frame coordinate
+ system (converts from Frame to referenceFrame()).
+
+ localCoordinatesOf() performs the inverse convertion. See also localInverseTransformOf(). */
+Vec Frame::localInverseCoordinatesOf(const Vec& src) const
+{
+  return rotation().rotate(src) + translation();
+}
+
+/*! Returns the Frame coordinates of the point whose position in the \p from coordinate system is \p
+  src (converts from \p from to Frame).
+
+  coordinatesOfIn() performs the inverse transformation. */
+Vec Frame::coordinatesOfFrom(const Vec& src, const Frame* const from) const
+{
+  if (this == from)
+    return src;
+  else
+    if (referenceFrame())
+      return localCoordinatesOf(referenceFrame()->coordinatesOfFrom(src, from));
+    else
+      return localCoordinatesOf(from->inverseCoordinatesOf(src));
+}
+
+/*! Returns the \p in coordinates of the point whose position in the Frame coordinate system is \p
+  src (converts from Frame to \p in).
+
+  coordinatesOfFrom() performs the inverse transformation. */
+Vec Frame::coordinatesOfIn(const Vec& src, const Frame* const in) const
+{
+  const Frame* fr = this;
+  Vec res = src;
+  while ((fr != NULL) && (fr != in))
+    {
+      res = fr->localInverseCoordinatesOf(res);
+      fr  = fr->referenceFrame();
+    }
+
+  if (fr != in)
+    // in was not found in the branch of this, res is now expressed in the world
+    // coordinate system. Simply convert to in coordinate system.
+    res = in->coordinatesOf(res);
+
+  return res;
+}
+
+////// float[3] versions
+
+/*! Same as coordinatesOf(), but with \c float parameters. */
+void Frame::getCoordinatesOf(const float src[3], float res[3]) const
+{
+  const Vec r = coordinatesOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as inverseCoordinatesOf(), but with \c float parameters. */
+void Frame::getInverseCoordinatesOf(const float src[3], float res[3]) const
+{
+  const Vec r = inverseCoordinatesOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as localCoordinatesOf(), but with \c float parameters. */
+void Frame::getLocalCoordinatesOf(const float src[3], float res[3]) const
+{
+  const Vec r = localCoordinatesOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+  /*! Same as localInverseCoordinatesOf(), but with \c float parameters. */
+void Frame::getLocalInverseCoordinatesOf(const float src[3], float res[3]) const
+{
+  const Vec r = localInverseCoordinatesOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as coordinatesOfIn(), but with \c float parameters. */
+void Frame::getCoordinatesOfIn(const float src[3], float res[3], const Frame* const in) const
+{
+  const Vec r = coordinatesOfIn(Vec(src), in);
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as coordinatesOfFrom(), but with \c float parameters. */
+void Frame::getCoordinatesOfFrom(const float src[3], float res[3], const Frame* const from) const
+{
+  const Vec r = coordinatesOfFrom(Vec(src), from);
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+
+///////////////////////// FRAME TRANSFORMATIONS OF VECTORS //////////////////////////////
+
+/*! Returns the Frame transform of a vector \p src defined in the world coordinate system (converts
+ vectors from world to Frame).
+
+ inverseTransformOf() performs the inverse transformation. coordinatesOf() converts 3D coordinates
+ instead of 3D vectors (here only the rotational part of the transformation is taken into account).
+
+ See the <a href="../examples/frameTransform.html">frameTransform example</a> for an
+ illustration. */
+Vec Frame::transformOf(const Vec& src) const
+{
+  if (referenceFrame())
+    return localTransformOf(referenceFrame()->transformOf(src));
+  else
+    return localTransformOf(src);
+}
+
+/*! Returns the world transform of the vector whose coordinates in the Frame coordinate
+  system is \p src (converts vectors from Frame to world).
+
+  transformOf() performs the inverse transformation. Use inverseCoordinatesOf() to transform 3D
+  coordinates instead of 3D vectors. */
+Vec Frame::inverseTransformOf(const Vec& src) const
+{
+  const Frame* fr = this;
+  Vec res = src;
+  while (fr != NULL)
+    {
+      res = fr->localInverseTransformOf(res);
+      fr  = fr->referenceFrame();
+    }
+  return res;
+}
+
+/*! Returns the Frame transform of a vector \p src defined in the referenceFrame() coordinate system
+  (converts vectors from referenceFrame() to Frame).
+
+  localInverseTransformOf() performs the inverse transformation. See also localCoordinatesOf(). */
+Vec Frame::localTransformOf(const Vec& src) const
+{
+  return rotation().inverseRotate(src);
+}
+
+/*! Returns the referenceFrame() transform of a vector \p src defined in the Frame coordinate
+ system (converts vectors from Frame to referenceFrame()).
+
+ localTransformOf() performs the inverse transformation. See also localInverseCoordinatesOf(). */
+Vec Frame::localInverseTransformOf(const Vec& src) const
+{
+  return rotation().rotate(src);
+}
+
+/*! Returns the Frame transform of the vector whose coordinates in the \p from coordinate system is \p
+  src (converts vectors from \p from to Frame).
+
+  transformOfIn() performs the inverse transformation. */
+Vec Frame::transformOfFrom(const Vec& src, const Frame* const from) const
+{
+  if (this == from)
+    return src;
+  else
+    if (referenceFrame())
+      return localTransformOf(referenceFrame()->transformOfFrom(src, from));
+    else
+      return localTransformOf(from->inverseTransformOf(src));
+}
+
+/*! Returns the \p in transform of the vector whose coordinates in the Frame coordinate system is \p
+  src (converts vectors from Frame to \p in).
+
+  transformOfFrom() performs the inverse transformation. */
+Vec Frame::transformOfIn(const Vec& src, const Frame* const in) const
+{
+  const Frame* fr = this;
+  Vec    res = src;
+  while ((fr != NULL) && (fr != in))
+    {
+      res = fr->localInverseTransformOf(res);
+      fr  = fr->referenceFrame();
+    }
+
+  if (fr != in)
+    // in was not found in the branch of this, res is now expressed in the world
+    // coordinate system. Simply convert to in coordinate system.
+    res = in->transformOf(res);
+
+  return res;
+}
+
+/////////////////  float[3] versions  //////////////////////
+
+/*! Same as transformOf(), but with \c float parameters. */
+void Frame::getTransformOf(const float src[3], float res[3]) const
+{
+  Vec r = transformOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as inverseTransformOf(), but with \c float parameters. */
+void Frame::getInverseTransformOf(const float src[3], float res[3]) const
+{
+  Vec r = inverseTransformOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as localTransformOf(), but with \c float parameters. */
+void Frame::getLocalTransformOf(const float src[3], float res[3]) const
+{
+  Vec r = localTransformOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as localInverseTransformOf(), but with \c float parameters. */
+void Frame::getLocalInverseTransformOf(const float src[3], float res[3]) const
+{
+  Vec r = localInverseTransformOf(Vec(src));
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as transformOfIn(), but with \c float parameters. */
+void Frame::getTransformOfIn(const float src[3], float res[3], const Frame* const in) const
+{
+  Vec r = transformOfIn(Vec(src), in);
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/*! Same as transformOfFrom(), but with \c float parameters. */
+void Frame::getTransformOfFrom(const float src[3], float res[3], const Frame* const from) const
+{
+  Vec r = transformOfFrom(Vec(src), from);
+  for (int i=0; i<3 ; ++i)
+    res[i] = r[i];
+}
+
+/////////////////////////////////   ALIGN   /////////////////////////////////
+
+/*! Aligns the Frame with \p frame, so that two of their axis are parallel.
+
+If one of the X, Y and Z axis of the Frame is almost parallel to any of the X, Y, or Z axis of \p
+frame, the Frame is rotated so that these two axis actually become parallel.
+
+If, after this first rotation, two other axis are also almost parallel, a second alignment is
+performed. The two frames then have identical orientations, up to 90 degrees rotations.
+
+\p threshold measures how close two axis must be to be considered parallel. It is compared with the
+absolute values of the dot product of the normalized axis.
+
+When \p move is set to \c true, the Frame position() is also affected by the alignment. The new
+Frame position() is such that the \p frame position (computed with coordinatesOf(), in the Frame
+coordinates system) does not change.
+
+\p frame may be \c NULL and then represents the world coordinate system (same convention than for
+the referenceFrame()).
+
+The rotation (and translation when \p move is \c true) applied to the Frame are filtered by the
+possible constraint(). */
+void Frame::alignWithFrame(const Frame* const frame, bool move, float threshold)
+{
+  Vec directions[2][3];
+  for (int d=0; d<3; ++d)
+    {
+      Vec dir((d==0)? 1.0 : 0.0, (d==1)? 1.0 : 0.0, (d==2)? 1.0 : 0.0);
+      if (frame)
+	directions[0][d] = frame->inverseTransformOf(dir);
+      else
+	directions[0][d] = dir;
+      directions[1][d] = inverseTransformOf(dir);
+    }
+
+  float maxProj = 0.0f;
+  float proj;
+  unsigned short index[2];
+  index[0] = index[1] = 0;
+  for (int i=0; i<3; ++i)
+    for (int j=0; j<3; ++j)
+      if ( (proj=fabs(directions[0][i]*directions[1][j])) >= maxProj )
+	{
+	  index[0] = i;
+	  index[1] = j;
+	  maxProj  = proj;
+	}
+
+  Frame old;
+  old=*this;
+
+  float coef = directions[0][index[0]] * directions[1][index[1]];
+  if (fabs(coef) >= threshold)
+    {
+      const Vec axis = cross(directions[0][index[0]], directions[1][index[1]]);
+      float angle = asin(axis.norm());
+      if (coef >= 0.0)
+	angle = -angle;
+      // setOrientation(Quaternion(axis, angle) * orientation());
+      rotate(rotation().inverse() * Quaternion(axis, angle) * orientation());
+
+      // Try to align an other axis direction
+      unsigned short d = (index[1]+1) % 3;
+      Vec dir((d==0)? 1.0 : 0.0, (d==1)? 1.0 : 0.0, (d==2)? 1.0 : 0.0);
+      dir = inverseTransformOf(dir);
+
+      float max = 0.0f;
+      for (int i=0; i<3; ++i)
+	{
+	  float proj = fabs(directions[0][i]*dir);
+	  if (proj > max)
+	    {
+	      index[0] = i;
+	      max = proj;
+	    }
+	}
+
+      if (max >= threshold)
+	{
+	  const Vec axis = cross(directions[0][index[0]], dir);
+	  float angle = asin(axis.norm());
+	  if (directions[0][index[0]] * dir >= 0.0)
+	    angle = -angle;
+	  // setOrientation(Quaternion(axis, angle) * orientation());
+	  rotate(rotation().inverse() * Quaternion(axis, angle) * orientation());
+	}
+    }
+
+  if (move)
+    {
+      Vec center;
+      if (frame)
+	center = frame->position();
+
+      // setPosition(center - orientation().rotate(old.coordinatesOf(center)));
+      translate(center - orientation().rotate(old.coordinatesOf(center)) - translation());
+    }
+}
+
+/*! Translates the Frame so that its position() lies on the line defined by \p origin and \p
+  direction (defined in the world coordinate system).
+
+Simply uses an orthogonal projection. \p direction does not need to be normalized. */
+void Frame::projectOnLine(const Vec& origin, const Vec& direction)
+{
+  // If you are trying to find a bug here, because of memory problems, you waste your time.
+  // This is a bug in the gcc 3.3 compiler. Compile the library in debug mode and test.
+  // Uncommenting this line also seems to solve the problem. Horrible.
+  // cout << "position = " << position() << endl;
+  // If you found a problem or are using a different compiler, please let me know.
+  const Vec shift = origin - position();
+  Vec proj = shift;
+  proj.projectOnAxis(direction);
+  translate(shift-proj);
+}
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.h
new file mode 100644
index 00000000000..30297499285
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_frame.h
@@ -0,0 +1,408 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_FRAME_H
+#define QGLVIEWER_FRAME_H
+
+#include "AppGLWidget_constraint.h"
+// #include "GL/gl.h" is now included in config.h for ease of configuration
+
+//namespace qglviewer {
+  /*! \brief The Frame class represents a coordinate system, defined by a position and an
+  orientation. \class Frame frame.h QGLViewer/frame.h
+
+  A Frame is a 3D coordinate system, represented by a position() and an orientation(). The order of
+  these transformations is important: the Frame is first translated \e and \e then rotated around
+  the new translated origin.
+
+  A Frame is useful to define the position and orientation of a 3D rigid object, using its matrix()
+  method, as shown below:
+  \code
+  // Builds a Frame at position (0.5,0,0) and oriented such that its Y axis is along the (1,1,1)
+  // direction. One could also have used setPosition() and setOrientation().
+  Frame fr(Vec(0.5,0,0), Quaternion(Vec(0,1,0), Vec(1,1,1)));
+  glPushMatrix();
+  glMultMatrixd(fr.matrix());
+  // Draw your object here, in the local fr coordinate system.
+  glPopMatrix();
+  \endcode
+
+  Many functions are provided to transform a 3D point from one coordinate system (Frame) to an
+  other: see coordinatesOf(), inverseCoordinatesOf(), coordinatesOfIn(), coordinatesOfFrom()...
+
+  You may also want to transform a 3D vector (such as a normal), which corresponds to applying only
+  the rotational part of the frame transformation: see transformOf() and inverseTransformOf(). See
+  the <a href="../examples/frameTransform.html">frameTransform example</a> for an illustration.
+
+  The translation() and the rotation() that are encapsulated in a Frame can also be used to
+  represent a \e rigid \e transformation of space. Such a transformation can also be interpreted as
+  a change of coordinate system, and the coordinate system conversion functions actually allow you
+  to use a Frame as a rigid transformation. Use inverseCoordinatesOf() (resp. coordinatesOf()) to
+  apply the transformation (resp. its inverse). Note the inversion.
+
+  <h3>Hierarchy of Frames</h3>
+
+  The position and the orientation of a Frame are actually defined with respect to a
+  referenceFrame(). The default referenceFrame() is the world coordinate system (represented by a \c
+  NULL referenceFrame()). If you setReferenceFrame() to a different Frame, you must then
+  differentiate:
+
+  \arg the \e local translation() and rotation(), defined with respect to the referenceFrame(),
+
+  \arg the \e global position() and orientation(), always defined with respect to the world
+  coordinate system.
+
+  A Frame is actually defined by its translation() with respect to its referenceFrame(), and then by
+  a rotation() of the coordinate system around the new translated origin.
+
+  This terminology for \e local (translation() and rotation()) and \e global (position() and
+  orientation()) definitions is used in all the methods' names and should be sufficient to prevent
+  ambiguities. These notions are obviously identical when the referenceFrame() is \c NULL, i.e. when
+  the Frame is defined in the world coordinate system (the one you are in at the beginning of the
+  QGLViewer::draw() method, see the <a href="../introduction.html">introduction page</a>).
+
+  Frames can hence easily be organized in a tree hierarchy, which root is the world coordinate
+  system. A loop in the hierarchy would result in an inconsistent (multiple) Frame definition.
+  settingAsReferenceFrameWillCreateALoop() checks this and prevents setReferenceFrame() from
+  creating such a loop.
+
+  This frame hierarchy is used in methods like coordinatesOfIn(), coordinatesOfFrom()... which allow
+  coordinates (or vector) conversions from a Frame to any other one (including the world coordinate
+  system).
+
+  However, one must note that this hierarchical representation is internal to the Frame classes.
+  When the Frames represent OpenGL coordinates system, one should map this hierarchical
+  representation to the OpenGL GL_MODELVIEW matrix stack. See the matrix() documentation for
+  details.
+
+  <h3>Constraints</h3>
+
+  An interesting feature of Frames is that their displacements can be constrained. When a Constraint
+  is attached to a Frame, it filters the input of translate() and rotate(), and only the resulting
+  filtered motion is applied to the Frame. The default constraint() is \c NULL resulting in no
+  filtering. Use setConstraint() to attach a Constraint to a frame.
+
+  Constraints are especially usefull for the ManipulatedFrame instances, in order to forbid some
+  mouse motions. See the <a href="../examples/constrainedFrame.html">constrainedFrame</a>, <a
+  href="../examples/constrainedCamera.html">constrainedCamera</a> and <a
+  href="../examples/luxo.html">luxo</a> examples for an illustration.
+
+  Classical constraints are provided for convenience (see LocalConstraint, WorldConstraint and
+  CameraConstraint) and new constraints can very easily be implemented.
+
+  <h3>Derived classes</h3>
+
+  The ManipulatedFrame class inherits Frame and implements a mouse motion convertion, so that a
+  Frame (and hence an object) can be manipulated in the scene with the mouse.
+
+  \nosubgrouping */
+  class Frame
+  {
+
+  public:
+    Frame();
+
+    /*! Virtual destructor. Empty. */
+    virtual ~Frame() {};
+
+    Frame(const Frame& frame);
+    Frame& operator=(const Frame& frame);
+
+    /*! This signal is emitted whenever the position() or the orientation() of the Frame is modified.
+
+    Connect this signal to any object that must be notified:
+    \code
+    QObject::connect(myFrame, SIGNAL(modified()), myObject, SLOT(update()));
+    \endcode
+    Use the QGLViewer::QGLViewerPool() to connect the signal to all the viewers.
+
+    \note If your Frame is part of a Frame hierarchy (see referenceFrame()), a modification of one
+    of the parents of this Frame will \e not emit this signal. Use code like this to change this
+    behavior (you can do this recursively for all the referenceFrame() until the \c NULL world root
+    frame is encountered):
+    \code
+    // Emits the Frame modified() signal when its referenceFrame() is modified().
+    connect(myFrame->referenceFrame(), SIGNAL(modified()), myFrame, SIGNAL(modified()));
+    \endcode
+
+    \attention Connecting this signal to a QGLWidget::updateGL() slot (or a method that calls it)
+    will prevent you from modifying the Frame \e inside your QGLViewer::draw() method as it would
+    result in an infinite loop. However, QGLViewer::draw() should not modify the scene.
+
+    \note For efficiency reasons, this signal is emitted even if the Frame is not actually modified, for
+    instance with translate(Vec(0,0,0)) or setPosition(position()). */
+    void modified();
+
+    /*! This signal is emitted when the Frame is interpolated by a KeyFrameInterpolator.
+
+    See the KeyFrameInterpolator documentation for details.
+
+    If a KeyFrameInterpolator is used to successively interpolate several Frames in your scene,
+    connect the KeyFrameInterpolator::interpolated() signal instead (identical, but independent of
+    the interpolated Frame). */
+    void interpolated();
+
+  public:
+    /*! @name World coordinates position and orientation */
+    //@{
+    Frame(const Vec& position, const Quaternion& orientation);
+
+    void setPosition(const Vec& position);
+    void setPosition(float x, float y, float z);
+    void setPositionWithConstraint(Vec& position);
+
+    void setOrientation(const Quaternion& orientation);
+    void setOrientation(double q0, double q1, double q2, double q3);
+    void setOrientationWithConstraint(Quaternion& orientation);
+
+    void setPositionAndOrientation(const Vec& position, const Quaternion& orientation);
+    void setPositionAndOrientationWithConstraint(Vec& position, Quaternion& orientation);
+
+    /*! Returns the position of the Frame, defined in the world coordinate system. See also
+      orientation(), setPosition() and translation(). */
+    Vec position() const { return inverseCoordinatesOf(Vec(0.0,0.0,0.0)); };
+    Quaternion orientation() const;
+
+    void getPosition(float& x, float& y, float& z) const;
+    void getOrientation(double& q0, double& q1, double& q2, double& q3) const;
+  //@}
+
+
+    public:
+    /*! @name Local translation and rotation w/r reference Frame */
+    //@{
+    /*! Sets the translation() of the frame, locally defined with respect to the referenceFrame().
+      Emits the modified() signal.
+
+    Use setPosition() to define the world coordinates position(). Use
+    setTranslationWithConstraint() to take into account the potential constraint() of the Frame. */
+    void setTranslation(const Vec& translation) { t_ = translation; };
+    void setTranslation(float x, float y, float z);
+    void setTranslationWithConstraint(Vec& translation);
+
+    /*! Set the current rotation Quaternion. See rotation() and the different Quaternion
+    constructors. Emits the modified() signal. See also setTranslation() and
+    setRotationWithConstraint(). */
+
+    /*! Sets the rotation() of the Frame, locally defined with respect to the referenceFrame().
+      Emits the modified() signal.
+
+     Use setOrientation() to define the world coordinates orientation(). The potential
+     constraint() of the Frame is not taken into account, use setRotationWithConstraint()
+     instead. */
+    void setRotation(const Quaternion& rotation) { q_ = rotation; };
+    void setRotation(double q0, double q1, double q2, double q3);
+    void setRotationWithConstraint(Quaternion& rotation);
+
+    void setTranslationAndRotation(const Vec& translation, const Quaternion& rotation);
+    void setTranslationAndRotationWithConstraint(Vec& translation, Quaternion& rotation);
+
+    /*! Returns the Frame translation, defined with respect to the referenceFrame().
+
+    Use position() to get the result in the world coordinates. These two values are identical
+    when the referenceFrame() is \c NULL (default).
+
+    See also setTranslation() and setTranslationWithConstraint(). */
+    Vec translation() const { return t_; };
+    /*! Returns the Frame rotation, defined with respect to the referenceFrame().
+
+    Use orientation() to get the result in the world coordinates. These two values are identical
+    when the referenceFrame() is \c NULL (default).
+
+    See also setRotation() and setRotationWithConstraint(). */
+
+    /*! Returns the current Quaternion orientation. See setRotation(). */
+    Quaternion rotation() const { return q_; };
+
+    void getTranslation(float& x, float& y, float& z) const;
+    void getRotation(double& q0, double& q1, double& q2, double& q3) const;
+    //@}
+
+    public:
+    /*! @name Frame hierarchy */
+    //@{
+    /*! Returns the reference Frame, in which coordinates system the Frame is defined.
+
+    The translation() and rotation() of the Frame are defined with respect to the referenceFrame()
+    coordinate system. A \c NULL referenceFrame() (default value) means that the Frame is defined in
+    the world coordinate system.
+
+    Use position() and orientation() to recursively convert values along the referenceFrame() chain
+    and to get values expressed in the world coordinate system. The values match when the
+    referenceFrame() is \c NULL.
+
+    Use setReferenceFrame() to set this value and create a Frame hierarchy. Convenient functions
+    allow you to convert 3D coordinates from one Frame to an other: see coordinatesOf(),
+    localCoordinatesOf(), coordinatesOfIn() and their inverse functions.
+
+    Vectors can also be converted using transformOf(), transformOfIn, localTransformOf() and their
+    inverse functions. */
+    const Frame* referenceFrame() const { return referenceFrame_; };
+    void setReferenceFrame(const Frame* const refFrame);
+    bool settingAsReferenceFrameWillCreateALoop(const Frame* const frame);
+    //@}
+
+
+    /*! @name Frame modification */
+    //@{
+    void translate(Vec& t);
+    void translate(const Vec& t);
+    // Some compilers complain about "overloading cannot distinguish from previous declaration"
+    // Simply comment out the following method and its associated implementation
+    void translate(float x, float y, float z);
+    void translate(float& x, float& y, float& z);
+
+    void rotate(Quaternion& q);
+    void rotate(const Quaternion& q);
+    // Some compilers complain about "overloading cannot distinguish from previous declaration"
+    // Simply comment out the following method and its associated implementation
+    void rotate(double q0, double q1, double q2, double q3);
+    void rotate(double& q0, double& q1, double& q2, double& q3);
+
+    void rotateAroundPoint(Quaternion& rotation, const Vec& point);
+    void rotateAroundPoint(const Quaternion& rotation, const Vec& point);
+
+    void alignWithFrame(const Frame* const frame, bool move=false, float threshold=0.85f);
+    void projectOnLine(const Vec& origin, const Vec& direction);
+    //@}
+
+
+    /*! @name Coordinate system transformation of 3D coordinates */
+    //@{
+    Vec coordinatesOf(const Vec& src) const;
+    Vec inverseCoordinatesOf(const Vec& src) const;
+    Vec localCoordinatesOf(const Vec& src) const;
+    Vec localInverseCoordinatesOf(const Vec& src) const;
+    Vec coordinatesOfIn(const Vec& src, const Frame* const in) const;
+    Vec coordinatesOfFrom(const Vec& src, const Frame* const from) const;
+
+    void getCoordinatesOf(const float src[3], float res[3]) const;
+    void getInverseCoordinatesOf(const float src[3], float res[3]) const;
+    void getLocalCoordinatesOf(const float src[3], float res[3]) const;
+    void getLocalInverseCoordinatesOf(const float src[3], float res[3]) const;
+    void getCoordinatesOfIn(const float src[3], float res[3], const Frame* const in) const;
+    void getCoordinatesOfFrom(const float src[3], float res[3], const Frame* const from) const;
+    //@}
+
+    /*! @name Coordinate system transformation of vectors */
+    // A frame is as a new coordinate system, defined with respect to a reference frame (the world
+    // coordinate system by default, see the "Composition of frame" section).
+
+    // The transformOf() (resp. inverseTransformOf()) functions transform a 3D vector from (resp.
+    // to) the world coordinates system. This section defines the 3D vector transformation
+    // functions. See the Coordinate system transformation of 3D points above for the transformation
+    // of 3D points. The difference between the two sets of functions is simple: for vectors, only
+    // the rotational part of the transformations is taken into account, while translation is also
+    // considered for 3D points.
+
+    // The length of the resulting transformed vector is identical to the one of the source vector
+    // for all the described functions.
+
+    // When local is prepended to the names of the functions, the functions simply transform from
+    // (and to) the reference frame.
+
+    // When In (resp. From) is appended to the names, the functions transform from (resp. To) the
+    // frame that is given as an argument. The frame does not need to be in the same branch or the
+    // hierarchical tree, and can be \c NULL (the world coordinates system).
+
+    // Combining any of these functions with its inverse (in any order) leads to the identity.
+    //@{
+    Vec transformOf(const Vec& src) const;
+    Vec inverseTransformOf(const Vec& src) const;
+    Vec localTransformOf(const Vec& src) const;
+    Vec localInverseTransformOf(const Vec& src) const;
+    Vec transformOfIn(const Vec& src, const Frame* const in) const;
+    Vec transformOfFrom(const Vec& src, const Frame* const from) const;
+
+    void getTransformOf(const float src[3], float res[3]) const;
+    void getInverseTransformOf(const float src[3], float res[3]) const;
+    void getLocalTransformOf(const float src[3], float res[3]) const;
+    void getLocalInverseTransformOf(const float src[3], float res[3]) const;
+    void getTransformOfIn(const float src[3], float res[3], const Frame* const in) const;
+    void getTransformOfFrom(const float src[3], float res[3], const Frame* const from) const;
+    //@}
+
+
+    /*! @name Constraint on the displacement */
+    //@{
+    /*! Returns the current constraint applied to the Frame.
+
+    A \c NULL value (default) means that no Constraint is used to filter Frame translation and
+    rotation. See the Constraint class documentation for details.
+
+    You may have to use a \c dynamic_cast to convert the result to a Constraint derived class. */
+    Constraint* constraint() const { return constraint_; }
+    /*! Sets the constraint() attached to the Frame.
+
+    A \c NULL value means no constraint. The previous constraint() should be deleted by the calling
+    method if needed. */
+    void setConstraint(Constraint* const constraint) { constraint_ = constraint; }
+    //@}
+
+    /*! @name Associated matrices */
+    //@{
+  public:
+    const GLdouble* matrix() const;
+    void getMatrix(GLdouble m[4][4]) const;
+    void getMatrix(GLdouble m[16]) const;
+
+    const GLdouble* worldMatrix() const;
+    void getWorldMatrix(GLdouble m[4][4]) const;
+    void getWorldMatrix(GLdouble m[16]) const;
+
+    void setFromMatrix(const GLdouble m[4][4]);
+    void setFromMatrix(const GLdouble m[16]);
+    //@}
+
+    /*! @name Inversion of the transformation */
+    //@{
+    Frame inverse() const;
+    /*! Returns the inverse() of the Frame world transformation.
+
+    The orientation() of the new Frame is the Quaternion::inverse() of the original orientation.
+    Its position() is the negated and inverse rotated image of the original position.
+
+    The result Frame has a \c NULL referenceFrame() and a \c NULL constraint().
+
+    Use inverse() for a local (i.e. with respect to referenceFrame()) transformation inverse. */
+    Frame worldInverse() const { return Frame(-(orientation().inverseRotate(position())), orientation().inverse()); }
+    //@}
+
+
+  private:
+    // P o s i t i o n   a n d   o r i e n t a t i o n
+    Vec t_;
+    Quaternion q_;
+
+    // C o n s t r a i n t s
+    Constraint* constraint_;
+
+    // F r a m e   c o m p o s i t i o n
+    const Frame* referenceFrame_;
+  };
+
+//} // namespace qglviewer
+
+#endif // QGLVIEWER_FRAME_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.cpp
new file mode 100644
index 00000000000..dafd64c4d19
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.cpp
@@ -0,0 +1,86 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_manipulatedCameraFrame.h"
+#include "AppGLWidget_camera.h"
+//#include "qglviewer.h"
+
+// #if QT_VERSION >= 0x040000
+// # include <QMouseEvent>
+// #endif
+// 
+// using namespace qglviewer;
+using namespace std;
+
+/*! Default constructor.
+
+ flySpeed() is set to 0.0 and flyUpVector() is (0,1,0). The revolveAroundPoint() is set to (0,0,0).
+
+  \attention Created object is removeFromMouseGrabberPool(). */
+ManipulatedCameraFrame::ManipulatedCameraFrame()
+  : driveSpeed_(0.0), flyUpVector_(0.0, 1.0, 0.0)
+{
+  setFlySpeed(0.0);
+  //removeFromMouseGrabberPool();
+
+  //connect(&flyTimer_, SIGNAL(timeout()), SLOT(flyUpdate()));
+}
+
+/*! Equal operator. Calls ManipulatedFrame::operator=() and then copy attributes. */
+ManipulatedCameraFrame& ManipulatedCameraFrame::operator=(const ManipulatedCameraFrame& mcf)
+{
+  ManipulatedFrame::operator=(mcf);
+
+  setFlySpeed(mcf.flySpeed());
+  setFlyUpVector(mcf.flyUpVector());
+
+  return *this;
+}
+
+/*! Copy constructor. Performs a deep copy of all members using operator=(). */
+ManipulatedCameraFrame::ManipulatedCameraFrame(const ManipulatedCameraFrame& mcf)
+  : ManipulatedFrame(mcf)
+{
+  //removeFromMouseGrabberPool();
+  (*this)=(mcf);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*! Returns a Quaternion that is a rotation around current camera Y, proportionnal to the horizontal mouse position. */
+Quaternion ManipulatedCameraFrame::turnQuaternion(int x, const AppGLWidget_Camera* const camera)
+{
+  return Quaternion(Vec(0.0, 1.0, 0.0), rotationSensitivity()*(prevPos_.x()-x)/camera->screenWidth());
+}
+
+/*! Returns a Quaternion that is the composition of two rotations, inferred from the
+  mouse pitch (X axis) and yaw (flyUpVector() axis). */
+Quaternion ManipulatedCameraFrame::pitchYawQuaternion(int x, int y, const AppGLWidget_Camera* const camera)
+{
+  const Quaternion rotX(Vec(1.0, 0.0, 0.0), rotationSensitivity()*(prevPos_.y()-y)/camera->screenHeight());
+  const Quaternion rotY(transformOf(flyUpVector()), rotationSensitivity()*(prevPos_.x()-x)/camera->screenWidth());
+  return rotY * rotX;
+}
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.h
new file mode 100644
index 00000000000..334fcfeade5
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedCameraFrame.h
@@ -0,0 +1,169 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
+#define QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
+
+#include "AppGLWidget_manipulatedFrame.h"
+
+//namespace qglviewer {
+  /*! \brief The ManipulatedCameraFrame class represents a ManipulatedFrame with Camera specific mouse bindings.
+  \class ManipulatedCameraFrame manipulatedCameraFrame.h QGLViewer/manipulatedCameraFrame.h
+
+  A ManipulatedCameraFrame is a specialization of a ManipulatedFrame, designed to be set as the
+  Camera::frame(). Mouse motions are basically interpreted in a negated way: when the mouse goes to
+  the right, the ManipulatedFrame translation goes to the right, while the ManipulatedCameraFrame
+  has to go to the \e left, so that the \e scene seems to move to the right.
+
+  A ManipulatedCameraFrame rotates around its revolveAroundPoint(), which corresponds to the
+  associated Camera::revolveAroundPoint().
+
+  A ManipulatedCameraFrame can also "fly" in the scene. It basically moves forward, and turns
+  according to the mouse motion. See flySpeed(), flyUpVector() and the QGLViewer::MOVE_FORWARD and
+  QGLViewer::MOVE_BACKWARD QGLViewer::MouseAction.
+
+  See the <a href="../mouse.html">mouse page</a> for a description of the possible actions that can
+  be performed using the mouse and their bindings.
+  \nosubgrouping */
+  class ManipulatedCameraFrame : public ManipulatedFrame
+  {
+#ifndef DOXYGEN
+    friend class AppGLWidget_Camera;
+    //friend class ::QGLViewer;
+#endif
+
+    //Q_OBJECT
+
+  public:
+    ManipulatedCameraFrame();
+    /*! Virtual destructor. Empty. */
+    virtual ~ManipulatedCameraFrame() {};
+
+    ManipulatedCameraFrame(const ManipulatedCameraFrame& mcf);
+    ManipulatedCameraFrame& operator=(const ManipulatedCameraFrame& mcf);
+
+    /*! @name Revolve around point */
+    //@{
+  public:
+    /*! Returns the point the ManipulatedCameraFrame revolves around when rotated.
+
+    It is defined in the world coordinate system. Default value is (0,0,0).
+
+    When the ManipulatedCameraFrame is associated to a Camera, Camera::revolveAroundPoint() also
+    returns this value. This point can interactively be changed using the mouse (see
+    QGLViewer::RAP_FROM_PIXEL and QGLViewer::RAP_IS_CENTER in the <a href="../mouse.html">mouse
+    page</a>). */
+    Vec revolveAroundPoint() const { return revolveAroundPoint_; }
+    /*! Sets the revolveAroundPoint(), defined in the world coordinate system. */
+    void setRevolveAroundPoint(const Vec& revolveAroundPoint) { revolveAroundPoint_ = revolveAroundPoint; }
+    //@}
+
+    /*! @name Fly parameters */
+    //@{
+  public: //slots:
+    /*! Sets the flySpeed(), defined in OpenGL units.
+
+    Default value is 0.0, but it is modified according to the QGLViewer::sceneRadius() when the
+    ManipulatedCameraFrame is set as the Camera::frame(). */
+    void setFlySpeed(float speed) { flySpeed_ = speed; };
+
+    /*! Sets the flyUpVector(), defined in the world coordinate system.
+
+    Default value is (0,1,0), but it is updated by the Camera when set as its Camera::frame(). Use
+    Camera::setUpVector() instead in that case. */
+    void setFlyUpVector(const Vec& up) { flyUpVector_ = up; };
+
+  public:
+    /*! Returns the fly speed, expressed in OpenGL units.
+
+    It corresponds to the incremental displacement that is periodically applied to the
+    ManipulatedCameraFrame position when a QGLViewer::MOVE_FORWARD or QGLViewer::MOVE_BACKWARD
+    QGLViewer::MouseAction is proceeded.
+
+    \attention When the ManipulatedCameraFrame is set as the Camera::frame(), this value is set
+    according to the QGLViewer::sceneRadius() by QGLViewer::setSceneRadius(). */
+    float flySpeed() const { return flySpeed_; };
+
+    /*! Returns the up vector used in fly mode, expressed in the world coordinate system.
+
+    Fly mode corresponds to the QGLViewer::MOVE_FORWARD and QGLViewer::MOVE_BACKWARD
+    QGLViewer::MouseAction bindings. In these modes, horizontal displacements of the mouse rotate
+    the ManipulatedCameraFrame around this vector. Vertical displacements rotate always around the
+    Camera \c X axis.
+
+    Default value is (0,1,0), but it is updated by the Camera when set as its Camera::frame().
+    Camera::setOrientation() and Camera::setUpVector()) modify this value and should be used
+    instead. */
+    Vec flyUpVector() const { return flyUpVector_; };
+    //@}
+
+    /*! @name Mouse event handlers */
+    //@{
+  // protected:
+  //   virtual void mouseReleaseEvent(QMouseEvent* const event, Camera* const camera);
+  //   virtual void mouseMoveEvent   (QMouseEvent* const event, Camera* const camera);
+  //   virtual void wheelEvent       (QWheelEvent* const event, Camera* const camera);
+  //   //@}
+
+    /*! @name Spinning */
+    //@{
+  // protected slots:
+  //   virtual void spin();
+    //@}
+
+    /*! @name XML representation */
+    //@{
+  // public:
+  //   virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
+  // public slots:
+  //   virtual void initFromDOMElement(const QDomElement& element);
+  //   //@}
+
+// #ifndef DOXYGEN
+//   protected:
+//     virtual void startAction(int ma, bool withConstraint=true); // int is really a QGLViewer::MouseAction
+// #endif
+
+  private: //slots:
+    //virtual void flyUpdate();
+
+  private:
+    void updateFlyUpVector();
+    Quaternion turnQuaternion(int x, const AppGLWidget_Camera* const camera);
+    Quaternion pitchYawQuaternion(int x, int y, const AppGLWidget_Camera* const camera);
+
+  private:
+    // Fly mode data
+    float flySpeed_;
+    float driveSpeed_;
+    Vec flyUpVector_;
+    //QTimer flyTimer_;
+
+    Vec revolveAroundPoint_;
+  };
+
+//} // namespace qglviewer
+
+#endif // QGLVIEWER_MANIPULATED_CAMERA_FRAME_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.cpp
new file mode 100644
index 00000000000..3ec5e83bf50
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.cpp
@@ -0,0 +1,116 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_manipulatedFrame.h"
+//#include "qglviewer.h"
+#include "AppGLWidget_camera.h"
+
+//using namespace qglviewer;
+using namespace std;
+
+/*! Default constructor.
+
+  The translation is set to (0,0,0), with an identity rotation (0,0,0,1) (see Frame constructor
+  for details).
+
+  The different sensitivities are set to their default values (see rotationSensitivity(),
+  translationSensitivity(), spinningSensitivity() and wheelSensitivity()). */
+ManipulatedFrame::ManipulatedFrame()
+{
+  // #CONNECTION# initFromDOMElement and accessor docs
+  setRotationSensitivity(1.0f);
+  setTranslationSensitivity(1.0f);
+  setSpinningSensitivity(0.3f);
+  setWheelSensitivity(1.0f);
+
+  isSpinning_ = false;
+  previousConstraint_ = false;
+
+  //connect(&spinningTimer_, SIGNAL(timeout()), SLOT(spinUpdate()));
+}
+
+/*! Equal operator. Calls Frame::operator=() and then copy attributes. */
+ManipulatedFrame& ManipulatedFrame::operator=(const ManipulatedFrame& mf)
+{
+  Frame::operator=(mf);
+
+  setRotationSensitivity(mf.rotationSensitivity());
+  setTranslationSensitivity(mf.translationSensitivity());
+  setSpinningSensitivity(mf.spinningSensitivity());
+  setWheelSensitivity(mf.wheelSensitivity());
+
+  mouseSpeed_ = 0.0;
+  dirIsFixed_ = false;
+  keepsGrabbingMouse_ = false;
+
+  return *this;
+}
+
+/*! Copy constructor. Performs a deep copy of all attributes using operator=(). */
+ManipulatedFrame::ManipulatedFrame(const ManipulatedFrame& mf)
+  : Frame(mf)
+{
+  (*this)=mf;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*! Returns "pseudo-distance" from (x,y) to ball of radius size.
+\arg for a point inside the ball, it is proportional to the euclidean distance to the ball
+\arg for a point outside the ball, it is proportional to the inverse of this distance (tends to
+zero) on the ball, the function is continuous. */
+static float projectOnBall(float x, float y)
+{
+  // If you change the size value, change angle computation in deformedBallQuaternion().
+  const float size       = 1.0f;
+  const float size2      = size*size;
+  const float size_limit = size2*0.5;
+
+  const float d = x*x + y*y;
+  return d < size_limit ? sqrt(size2 - d) : size_limit/sqrt(d);
+}
+
+#ifndef DOXYGEN
+/*! Returns a quaternion computed according to the mouse motion. Mouse positions are projected on a
+deformed ball, centered on (\p cx,\p cy). */
+Quaternion ManipulatedFrame::deformedBallQuaternion(int x, int y, float cx, float cy, const AppGLWidget_Camera* const camera)
+{
+  // Points on the deformed ball
+  float px = rotationSensitivity() * (prevPos_.x()  - cx) / camera->screenWidth();
+  float py = rotationSensitivity() * (cy - prevPos_.y())  / camera->screenHeight();
+  float dx = rotationSensitivity() * (x - cx)	    / camera->screenWidth();
+  float dy = rotationSensitivity() * (cy - y)	    / camera->screenHeight();
+
+  const Vec p1(px, py, projectOnBall(px, py));
+  const Vec p2(dx, dy, projectOnBall(dx, dy));
+  // Approximation of rotation angle
+  // Should be divided by the projectOnBall size, but it is 1.0
+  const Vec axis = cross(p2,p1);
+  const float angle = 2.0 * asin(sqrt(axis.squaredNorm() / p1.squaredNorm() / p2.squaredNorm()));
+  return Quaternion(axis, angle);
+}
+#endif // DOXYGEN
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.h
new file mode 100644
index 00000000000..e57dd9fc756
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_manipulatedFrame.h
@@ -0,0 +1,256 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_MANIPULATED_FRAME_H
+#define QGLVIEWER_MANIPULATED_FRAME_H
+
+#include "AppGLWidget_frame.h"
+
+//namespace qglviewer {
+  /*! \brief A ManipulatedFrame is a Frame that can be rotated and translated using the mouse.
+  \class ManipulatedFrame manipulatedFrame.h QGLViewer/manipulatedFrame.h
+
+  It converts the mouse motion into a translation and an orientation updates. A ManipulatedFrame is
+  used to move an object in the scene. Combined with object selection, its MouseGrabber properties
+  and a dynamic update of the scene, the ManipulatedFrame introduces a great reactivity in your
+  applications.
+
+  A ManipulatedFrame is attached to a QGLViewer using QGLViewer::setManipulatedFrame():
+  \code
+  init() { setManipulatedFrame( new ManipulatedFrame() ); }
+
+  draw()
+  {
+    glPushMatrix();
+    glMultMatrixd(manipulatedFrame()->matrix());
+    // draw the manipulated object here
+    glPopMatrix();
+  }
+  \endcode
+  See the <a href="../examples/manipulatedFrame.html">manipulatedFrame example</a> for a complete
+  application.
+
+  Mouse events are normally sent to the QGLViewer::camera(). You have to press the QGLViewer::FRAME
+  state key (default is \c Control) to move the QGLViewer::manipulatedFrame() instead. See the <a
+  href="../mouse.html">mouse page</a> for a description of mouse button bindings.
+
+  <h3>Inherited functionalities</h3>
+
+  A ManipulatedFrame is an overloaded instance of a Frame. The powerful coordinate system
+  transformation functions (Frame::coordinatesOf(), Frame::transformOf(), ...) can hence be applied
+  to a ManipulatedFrame.
+
+  A ManipulatedFrame is also a MouseGrabber. If the mouse cursor gets within a distance of 10 pixels
+  from the projected position of the ManipulatedFrame, the ManipulatedFrame becomes the new
+  QGLViewer::mouseGrabber(). It can then be manipulated directly, without any specific state key,
+  object selection or GUI intervention. This is very convenient to directly move some objects in the
+  scene (typically a light). See the <a href="../examples/mouseGrabber.html">mouseGrabber
+  example</a> as an illustration. Note that QWidget::setMouseTracking() needs to be enabled in order
+  to use this feature (see the MouseGrabber documentation).
+
+  <h3>Advanced functionalities</h3>
+
+  A QGLViewer can handle at most one ManipulatedFrame at a time. If you want to move several objects
+  in the scene, you simply have to keep a list of the different ManipulatedFrames, and to activate
+  the right one (using QGLViewer::setManipulatedFrame()) when needed. This can for instance be done
+  according to an object selection: see the <a href="../examples/luxo.html">luxo example</a> for an
+  illustration.
+
+  When the ManipulatedFrame is being manipulated using the mouse (mouse pressed and not yet
+  released), isManipulated() returns \c true. This might be used to trigger a specific action or
+  display (as is done with QGLViewer::fastDraw()).
+
+  The ManipulatedFrame also emits a manipulated() signal each time its state is modified by the
+  mouse. This signal is automatically connected to the QGLViewer::updateGL() slot when the
+  ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame().
+
+  You can make the ManipulatedFrame spin() if you release the rotation mouse button while moving the
+  mouse fast enough (see spinningSensitivity()). See also translationSensitivity() and
+  rotationSensitivity() for sensitivity tuning. \nosubgrouping */
+  class ManipulatedFrame : public Frame
+  {
+
+  public:
+    ManipulatedFrame();
+    /*! Virtual destructor. Empty. */
+    virtual ~ManipulatedFrame() {};
+
+    ManipulatedFrame(const ManipulatedFrame& mf);
+    ManipulatedFrame& operator=(const ManipulatedFrame& mf);
+
+    /*! This signal is emitted when ever the ManipulatedFrame is manipulated (i.e. rotated or
+    translated) using the mouse. Connect this signal to any object that should be notified.
+
+    Note that this signal is automatically connected to the QGLViewer::updateGL() slot, when the
+    ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame(), which is
+    probably all you need.
+
+    Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.
+
+    See also the spun(), modified(), interpolated() and KeyFrameInterpolator::interpolated()
+    signals' documentations. */
+    void manipulated();
+
+    /*! This signal is emitted when the ManipulatedFrame isSpinning().
+
+    Note that for the QGLViewer::manipulatedFrame(), this signal is automatically connected to the
+    QGLViewer::updateGL() slot.
+
+    Connect this signal to any object that should be notified. Use the QGLViewer::QGLViewerPool() if
+    you need to connect this signal to all the viewers.
+
+    See also the manipulated(), modified(), interpolated() and KeyFrameInterpolator::interpolated()
+    signals' documentations. */
+    void spun();
+
+    /*! @name Manipulation sensitivity */
+    //@{
+  public:
+    /*! Defines the rotationSensitivity(). */
+    void setRotationSensitivity(float sensitivity) { rotSensitivity_ = sensitivity; };
+    /*! Defines the translationSensitivity(). */
+    void setTranslationSensitivity(float sensitivity) { transSensitivity_ = sensitivity; };
+    /*! Defines the spinningSensitivity(), in pixels per milliseconds. */
+    void setSpinningSensitivity(float sensitivity) { spinningSensitivity_ = sensitivity; };
+    /*! Defines the wheelSensitivity(). */
+    void setWheelSensitivity(float sensitivity) { wheelSensitivity_ = sensitivity; };
+  public:
+    /*! Returns the influence of a mouse displacement on the ManipulatedFrame rotation.
+
+    Default value is 1.0. With an identical mouse displacement, a higher value will generate a
+    larger rotation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse
+    rotation (see also constraint()).
+
+    See also setRotationSensitivity(), translationSensitivity(), spinningSensitivity() and
+    wheelSensitivity(). */
+    float rotationSensitivity() const { return rotSensitivity_; };
+    /*! Returns the influence of a mouse displacement on the ManipulatedFrame translation.
+
+    Default value is 1.0. You should not have to modify this value, since with 1.0 the
+    ManipulatedFrame precisely stays under the mouse cursor.
+
+    With an identical mouse displacement, a higher value will generate a larger translation (and
+    inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse translation (see
+    also constraint()).
+
+    \note When the ManipulatedFrame is used to move a \e Camera (see the ManipulatedCameraFrame
+    class documentation), after zooming on a small region of your scene, the camera may translate
+    too fast. For a camera, it is the Camera::revolveAroundPoint() that exactly matches the mouse
+    displacement. Hence, instead of changing the translationSensitivity(), solve the problem by
+    (temporarily) setting the Camera::revolveAroundPoint() to a point on the zoomed region (see the
+    QGLViewer::RAP_FROM_PIXEL mouse binding in the <a href="../mouse.html">mouse page</a>).
+
+    See also setTranslationSensitivity(), rotationSensitivity(), spinningSensitivity() and
+    wheelSensitivity(). */
+    float translationSensitivity() const { return transSensitivity_; };
+    /*! Returns the minimum mouse speed required (at button release) to make the ManipulatedFrame
+      spin().
+
+    See spin(), spinningQuaternion() and startSpinning() for details.
+
+    Mouse speed is expressed in pixels per milliseconds. Default value is 0.3 (300 pixels per
+    second). Use setSpinningSensitivity() to tune this value. A higher value will make spinning more
+    difficult (a value of 100.0 forbids spinning in practice).
+
+    See also setSpinningSensitivity(), translationSensitivity(), rotationSensitivity() and
+    wheelSensitivity(). */
+    float spinningSensitivity() const { return spinningSensitivity_; };
+    /*! Returns the mouse wheel sensitivity.
+
+    Default value is 1.0. A higher value will make the wheel action more efficient (usually meaning
+    a faster zoom). Use a negative value to invert the zoom in and out directions.
+
+    See also setWheelSensitivity(), translationSensitivity(), rotationSensitivity() and
+    spinningSensitivity(). */
+    float wheelSensitivity() const { return wheelSensitivity_; };
+    //@}
+
+
+    /*! @name Spinning */
+    //@{
+      public:
+    /*! Returns \c true when the ManipulatedFrame is spinning.
+
+    During spinning, spin() rotates the ManipulatedFrame by its spinningQuaternion() at a frequency
+    defined when the ManipulatedFrame startSpinning().
+
+    Use startSpinning() and stopSpinning() to change this state. Default value is \c false. */
+    bool isSpinning() const { return isSpinning_; };
+    /*! Returns the incremental rotation that is applied by spin() to the ManipulatedFrame
+      orientation when it isSpinning().
+
+     Default value is a null rotation (identity Quaternion). Use setSpinningQuaternion() to change
+     this value.
+
+     The spinningQuaternion() axis is defined in the ManipulatedFrame coordinate system. You can use
+     Frame::transformOfFrom() to convert this axis from an other Frame coordinate system. */
+    Quaternion spinningQuaternion() const { return spinningQuaternion_; }
+  public:
+  /*! Defines the spinningQuaternion(). Its axis is defined in the ManipulatedFrame coordinate
+    system. */
+    void setSpinningQuaternion(const Quaternion& spinningQuaternion) { spinningQuaternion_ = spinningQuaternion; }
+  protected:
+    //virtual void spin();
+  private:
+    void spinUpdate();
+    //@}
+
+
+#ifndef DOXYGEN
+  protected:
+    Quaternion deformedBallQuaternion(int x, int y, float cx, float cy, const AppGLWidget_Camera* const camera);
+
+    int action_; // Should be a QGLViewer::MouseAction, but include loop
+    Constraint* previousConstraint_; // When manipulation is without Contraint.
+
+    //virtual void startAction(int ma, bool withConstraint=true); // int is really a QGLViewer::MouseAction
+
+    // Previous mouse position (used for incremental updates) and mouse press position.
+    Point prevPos_, pressPos_;
+#endif // DOXYGEN
+
+  private:
+    // Sensitivity
+    float rotSensitivity_;
+    float transSensitivity_;
+    float spinningSensitivity_;
+    float wheelSensitivity_;
+
+    // Mouse speed and spinning
+    float mouseSpeed_;
+    int delay_;
+    bool isSpinning_;
+    Quaternion spinningQuaternion_;
+
+    // Whether the SCREEN_TRANS direction (horizontal or vertical) is fixed or not.
+    bool dirIsFixed_;
+
+    // MouseGrabber
+    bool keepsGrabbingMouse_;
+  };
+
+//} // namespace qglviewer
+
+#endif // QGLVIEWER_MANIPULATED_FRAME_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_point.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_point.h
new file mode 100644
index 00000000000..4250922239d
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_point.h
@@ -0,0 +1,159 @@
+#ifndef POINT_H
+#define POINT_H
+
+typedef int QCOORD; 
+
+class Point
+{
+public:
+    Point();
+    Point( int xpos, int ypos );
+
+    bool   isNull()	const;
+
+    int	   x()		const;
+    int	   y()		const;
+    void   setX( int x );
+    void   setY( int y );
+
+    int manhattanLength() const;
+
+    QCOORD &rx();
+    QCOORD &ry();
+
+    Point &operator+=( const Point &p );
+    Point &operator-=( const Point &p );
+    Point &operator*=( int c );
+    Point &operator*=( double c );
+    Point &operator/=( int c );
+    Point &operator/=( double c );
+
+    friend inline bool	 operator==( const Point &, const Point & );
+    friend inline bool	 operator!=( const Point &, const Point & );
+    friend inline const Point operator+( const Point &, const Point & );
+    friend inline const Point operator-( const Point &, const Point & );
+    friend inline const Point operator*( const Point &, int );
+    friend inline const Point operator*( int, const Point & );
+    friend inline const Point operator*( const Point &, double );
+    friend inline const Point operator*( double, const Point & );
+    friend inline const Point operator-( const Point & );
+    friend inline const Point operator/( const Point &, int );
+    friend inline const Point operator/( const Point &, double );
+
+private:
+    QCOORD xp;
+    QCOORD yp;
+};
+
+static void warningDivByZero() {
+	// cout << "warning: dividing by zero"
+}
+
+
+/*****************************************************************************
+  Point inline functions
+ *****************************************************************************/
+
+inline Point::Point()
+{ xp=0; yp=0; }
+
+inline Point::Point( int xpos, int ypos )
+{ xp=(QCOORD)xpos; yp=(QCOORD)ypos; }
+
+inline bool Point::isNull() const
+{ return xp == 0 && yp == 0; }
+
+inline int Point::x() const
+{ return xp; }
+
+inline int Point::y() const
+{ return yp; }
+
+inline void Point::setX( int x )
+{ xp = (QCOORD)x; }
+
+inline void Point::setY( int y )
+{ yp = (QCOORD)y; }
+
+inline QCOORD &Point::rx()
+{ return xp; }
+
+inline QCOORD &Point::ry()
+{ return yp; }
+
+inline Point &Point::operator+=( const Point &p )
+{ xp+=p.xp; yp+=p.yp; return *this; }
+
+inline Point &Point::operator-=( const Point &p )
+{ xp-=p.xp; yp-=p.yp; return *this; }
+
+inline Point &Point::operator*=( int c )
+{ xp*=(QCOORD)c; yp*=(QCOORD)c; return *this; }
+
+inline Point &Point::operator*=( double c )
+{ xp=(QCOORD)(xp*c); yp=(QCOORD)(yp*c); return *this; }
+
+inline bool operator==( const Point &p1, const Point &p2 )
+{ return p1.xp == p2.xp && p1.yp == p2.yp; }
+
+inline bool operator!=( const Point &p1, const Point &p2 )
+{ return p1.xp != p2.xp || p1.yp != p2.yp; }
+
+inline const Point operator+( const Point &p1, const Point &p2 )
+{ return Point(p1.xp+p2.xp, p1.yp+p2.yp); }
+
+inline const Point operator-( const Point &p1, const Point &p2 )
+{ return Point(p1.xp-p2.xp, p1.yp-p2.yp); }
+
+inline const Point operator*( const Point &p, int c )
+{ return Point(p.xp*c, p.yp*c); }
+
+inline const Point operator*( int c, const Point &p )
+{ return Point(p.xp*c, p.yp*c); }
+
+inline const Point operator*( const Point &p, double c )
+{ return Point((QCOORD)(p.xp*c), (QCOORD)(p.yp*c)); }
+
+inline const Point operator*( double c, const Point &p )
+{ return Point((QCOORD)(p.xp*c), (QCOORD)(p.yp*c)); }
+
+inline const Point operator-( const Point &p )
+{ return Point(-p.xp, -p.yp); }
+
+inline Point &Point::operator/=( int c )
+{
+    if ( c == 0 )
+		warningDivByZero();
+
+    xp/=(QCOORD)c;
+    yp/=(QCOORD)c;
+    return *this;
+}
+
+inline Point &Point::operator/=( double c )
+{
+    if ( c == 0.0 )
+		warningDivByZero();
+
+    xp=(QCOORD)(xp/c);
+    yp=(QCOORD)(yp/c);
+    return *this;
+}
+
+inline const Point operator/( const Point &p, int c )
+{
+    if ( c == 0 )
+		warningDivByZero();
+	
+    return Point(p.xp/c, p.yp/c);
+}
+
+inline const Point operator/( const Point &p, double c )
+{
+    if ( c == 0.0 )
+		warningDivByZero();
+
+    return Point((QCOORD)(p.xp/c), (QCOORD)(p.yp/c));
+}
+
+#endif // POINT_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.cpp
new file mode 100644
index 00000000000..77219cdce1a
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.cpp
@@ -0,0 +1,502 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_quaternion.h"
+#include <stdlib.h> // RAND_MAX
+
+// All the methods are declared inline in Quaternion.h
+using namespace std;
+
+/*! Constructs a Quaternion that will rotate from the \p from direction to the \p to direction.
+
+Note that this rotation is not uniquely defined. The selected axis is usually orthogonal to \p from
+and \p to. However, this method is robust and can handle small or almost identical vectors. */
+Quaternion::Quaternion(const Vec& from, const Vec& to)
+{
+  const float epsilon = 1E-10f;
+
+  const float fromSqNorm = from.squaredNorm();
+  const float toSqNorm   = to.squaredNorm();
+  // Identity Quaternion when one vector is null
+  if ((fromSqNorm < epsilon) || (toSqNorm < epsilon))
+    {
+      q[0]=q[1]=q[2]=0.0;
+      q[3]=1.0;
+    }
+  else
+    {
+      Vec axis = cross(from, to);
+      const float axisSqNorm = axis.squaredNorm();
+
+      // Aligned vectors, pick any axis, not aligned with from or to
+      if (axisSqNorm < epsilon)
+	axis = from.orthogonalVec();
+
+      double angle = asin(sqrt(axisSqNorm / (fromSqNorm * toSqNorm)));
+
+      if (from*to < 0.0)
+	angle = M_PI-angle;
+
+      setAxisAngle(axis, angle);
+    }
+}
+
+/*! Returns the image of \p v by the Quaternion inverse() rotation.
+
+rotate() performs an inverse transformation. Same as inverse().rotate(v). */
+Vec Quaternion::inverseRotate(const Vec& v) const
+{
+  return inverse().rotate(v);
+}
+
+/*! Returns the image of \p v by the Quaternion rotation.
+
+See also inverseRotate() and operator*(const Quaternion&, const Vec&). */
+Vec Quaternion::rotate(const Vec& v) const
+{
+  const double q00 = 2.0l * q[0] * q[0];
+  const double q11 = 2.0l * q[1] * q[1];
+  const double q22 = 2.0l * q[2] * q[2];
+
+  const double q01 = 2.0l * q[0] * q[1];
+  const double q02 = 2.0l * q[0] * q[2];
+  const double q03 = 2.0l * q[0] * q[3];
+
+  const double q12 = 2.0l * q[1] * q[2];
+  const double q13 = 2.0l * q[1] * q[3];
+
+  const double q23 = 2.0l * q[2] * q[3];
+
+  return Vec((1.0 - q11 - q22)*v[0] + (      q01 - q23)*v[1] + (      q02 + q13)*v[2],
+	     (      q01 + q23)*v[0] + (1.0 - q22 - q00)*v[1] + (      q12 - q03)*v[2],
+	     (      q02 - q13)*v[0] + (      q12 + q03)*v[1] + (1.0 - q11 - q00)*v[2] );
+}
+
+/*! Set the Quaternion from a (supposedly correct) 3x3 rotation matrix.
+
+  The matrix is expressed in European format: its three \e columns are the images by the rotation of
+  the three vectors of an orthogonal basis. Note that OpenGL uses a symmetric representation for its
+  matrices.
+
+  setFromRotatedBasis() sets a Quaternion from the three axis of a rotated frame. It actually fills
+  the three columns of a matrix with these rotated basis vectors and calls this method. */
+void Quaternion::setFromRotationMatrix(const double m[3][3])
+{
+  // Compute one plus the trace of the matrix
+  const double onePlusTrace = 1.0 + m[0][0] + m[1][1] + m[2][2];
+
+  if (onePlusTrace > 1E-5)
+    {
+      // Direct computation
+      const double s = sqrt(onePlusTrace) * 2.0;
+      q[0] = (m[2][1] - m[1][2]) / s;
+      q[1] = (m[0][2] - m[2][0]) / s;
+      q[2] = (m[1][0] - m[0][1]) / s;
+      q[3] = 0.25 * s;
+    }
+  else
+    {
+      // Computation depends on major diagonal term
+      if ((m[0][0] > m[1][1])&(m[0][0] > m[2][2]))
+	{ 
+	  const double s = sqrt(1.0 + m[0][0] - m[1][1] - m[2][2]) * 2.0; 
+	  q[0] = 0.25 * s;
+	  q[1] = (m[0][1] + m[1][0]) / s; 
+	  q[2] = (m[0][2] + m[2][0]) / s; 
+	  q[3] = (m[1][2] - m[2][1]) / s;
+	}
+      else
+	if (m[1][1] > m[2][2])
+	  { 
+	    const double s = sqrt(1.0 + m[1][1] - m[0][0] - m[2][2]) * 2.0; 
+	    q[0] = (m[0][1] + m[1][0]) / s; 
+	    q[1] = 0.25 * s;
+	    q[2] = (m[1][2] + m[2][1]) / s; 
+	    q[3] = (m[0][2] - m[2][0]) / s;
+	  }
+	else
+	  { 
+	    const double s = sqrt(1.0 + m[2][2] - m[0][0] - m[1][1]) * 2.0; 
+	    q[0] = (m[0][2] + m[2][0]) / s; 
+	    q[1] = (m[1][2] + m[2][1]) / s; 
+	    q[2] = 0.25 * s;
+	    q[3] = (m[0][1] - m[1][0]) / s;
+	  }
+    }
+  normalize();
+}
+
+#ifndef DOXYGEN
+void Quaternion::setFromRotationMatrix(const float m[3][3])
+{
+  cout << "setFromRotationMatrix now waits for a double[3][3] parameter" << endl;
+
+  double mat[3][3];
+  for (int i=0; i<3; ++i)
+    for (int j=0; j<3; ++j)
+      mat[i][j] = double(m[i][j]);
+
+  setFromRotationMatrix(mat);
+}
+
+void Quaternion::setFromRotatedBase(const Vec& X, const Vec& Y, const Vec& Z)
+{
+  cout << "setFromRotatedBase is deprecated, use setFromRotatedBasis instead" << endl;
+  setFromRotatedBasis(X,Y,Z);
+}
+#endif
+
+/*! Sets the Quaternion from the three rotated vectors of an orthogonal basis.
+
+  The three vectors do not have to be normalized but must be orthogonal and direct (X^Y=k*Z, with k>0).
+
+  \code
+  Quaternion q;
+  q.setFromRotatedBasis(X, Y, Z);
+  // Now q.rotate(Vec(1,0,0)) == X and q.inverseRotate(X) == Vec(1,0,0)
+  // Same goes for Y and Z with Vec(0,1,0) and Vec(0,0,1).
+  \endcode
+
+  See also setFromRotationMatrix() and Quaternion(const Vec&, const Vec&). */
+void Quaternion::setFromRotatedBasis(const Vec& X, const Vec& Y, const Vec& Z)
+{
+  double m[3][3];
+  double normX = X.norm();
+  double normY = Y.norm();
+  double normZ = Z.norm();
+
+  for (int i=0; i<3; ++i)
+    {
+      m[i][0] = X[i] / normX;
+      m[i][1] = Y[i] / normY;
+      m[i][2] = Z[i] / normZ;
+    }
+  
+  setFromRotationMatrix(m);
+}
+
+/*! Returns the axis vector and the angle (in radians) of the rotation represented by the Quaternion.
+ See the axis() and angle() documentations. */
+void Quaternion::getAxisAngle(Vec& axis, float& angle) const
+{
+  angle = 2.0*acos(q[3]);
+  axis = Vec(q[0], q[1], q[2]);
+  const float sinus = axis.norm();
+  if (sinus > 1E-8)
+    axis /= sinus;
+
+  if (angle > M_PI)
+    {
+      angle = 2.0*M_PI - angle;
+      axis = -axis;
+    }
+}
+
+/*! Returns the normalized axis direction of the rotation represented by the Quaternion.
+
+It is null for an identity Quaternion. See also angle() and getAxisAngle(). */
+Vec Quaternion::axis() const
+{
+  Vec res = Vec(q[0], q[1], q[2]);
+  const float sinus = res.norm();
+  if (sinus > 1E-8)
+    res /= sinus;
+  return (acos(q[3]) <= M_PI/2.0) ? res : -res;
+}
+
+/*! Returns the angle (in radians) of the rotation represented by the Quaternion.
+
+ This value is always in the range [0-pi]. Larger rotational angles are obtained by inverting the
+ axis() direction.
+
+ See also axis() and getAxisAngle(). */
+float Quaternion::angle() const
+{
+  const float angle = 2.0 * acos(q[3]);
+  return (angle <= M_PI) ? angle : 2.0*M_PI - angle;
+}
+
+
+
+
+/*! Returns the Quaternion associated 4x4 OpenGL rotation matrix.
+
+ Use \c glMultMatrixd(q.matrix()) to apply the rotation represented by Quaternion \c q to the
+ current OpenGL matrix.
+
+ See also getMatrix(), getRotationMatrix() and inverseMatrix().
+
+ \attention The result is only valid until the next call to matrix(). Use it immediately (as shown
+ above) or consider using getMatrix() instead.
+
+ \attention The matrix is given in OpenGL format (row-major order) and is the transpose of the
+ actual mathematical European representation. Consider using getRotationMatrix() instead. */
+const GLdouble* Quaternion::matrix() const
+{
+  static GLdouble m[4][4];
+  getMatrix(m);
+  return (const GLdouble*)(m);
+}
+
+/*! Fills \p m with the OpenGL representation of the Quaternion rotation.
+
+Use matrix() if you do not need to store this matrix and simply want to alter the current OpenGL
+matrix. See also getInverseMatrix() and Frame::getMatrix(). */
+void Quaternion::getMatrix(GLdouble m[4][4]) const
+{
+  const double q00 = 2.0l * q[0] * q[0];
+  const double q11 = 2.0l * q[1] * q[1];
+  const double q22 = 2.0l * q[2] * q[2];
+
+  const double q01 = 2.0l * q[0] * q[1];
+  const double q02 = 2.0l * q[0] * q[2];
+  const double q03 = 2.0l * q[0] * q[3];
+
+  const double q12 = 2.0l * q[1] * q[2];
+  const double q13 = 2.0l * q[1] * q[3];
+
+  const double q23 = 2.0l * q[2] * q[3];
+
+  m[0][0] = 1.0l - q11 - q22;
+  m[1][0] =        q01 - q23;
+  m[2][0] =        q02 + q13;
+
+  m[0][1] =        q01 + q23;
+  m[1][1] = 1.0l - q22 - q00;
+  m[2][1] =        q12 - q03;
+
+  m[0][2] =        q02 - q13;
+  m[1][2] =        q12 + q03;
+  m[2][2] = 1.0l - q11 - q00;
+
+  m[0][3] = 0.0l;
+  m[1][3] = 0.0l;
+  m[2][3] = 0.0l;
+
+  m[3][0] = 0.0l;
+  m[3][1] = 0.0l;
+  m[3][2] = 0.0l;
+  m[3][3] = 1.0l;
+}
+
+/*! Same as getMatrix(), but with a \c GLdouble[16] parameter. See also getInverseMatrix() and Frame::getMatrix(). */
+void Quaternion::getMatrix(GLdouble m[16]) const
+{
+  static GLdouble mat[4][4];
+  getMatrix(mat);
+  int count = 0;
+  for (int i=0; i<4; ++i)
+    for (int j=0; j<4; ++j)
+      m[count++] = mat[i][j];
+}
+
+/*! Fills \p m with the 3x3 rotation matrix associated with the Quaternion.
+
+  See also getInverseRotationMatrix().
+
+  \attention \p m uses the European mathematical representation of the rotation matrix. Use matrix()
+  and getMatrix() to retrieve the OpenGL transposed version. */
+void Quaternion::getRotationMatrix(float m[3][3]) const
+{
+  static GLdouble mat[4][4];
+  getMatrix(mat);
+  for (int i=0; i<3; ++i)
+    for (int j=0; j<3; ++j)
+      // Beware of transposition
+      m[i][j] = mat[j][i];
+}
+
+/*! Returns the associated 4x4 OpenGL \e inverse rotation matrix. This is simply the matrix() of the
+  inverse().
+
+  \attention The result is only valid until the next call to inverseMatrix(). Use it immediately (as
+  in \c glMultMatrixd(q.inverseMatrix())) or use getInverseMatrix() instead.
+
+  \attention The matrix is given in OpenGL format (row-major order) and is the transpose of the
+  actual mathematical European representation. Consider using getInverseRotationMatrix() instead. */
+const GLdouble* Quaternion::inverseMatrix() const
+{
+  static GLdouble m[4][4];
+  getInverseMatrix(m);
+  return (const GLdouble*)(m);
+}
+
+/*! Fills \p m with the OpenGL matrix corresponding to the inverse() rotation.
+
+Use inverseMatrix() if you do not need to store this matrix and simply want to alter the current
+OpenGL matrix. See also getMatrix(). */
+void Quaternion::getInverseMatrix(GLdouble m[4][4]) const
+{
+  inverse().getMatrix(m);
+}
+
+/*! Same as getInverseMatrix(), but with a \c GLdouble[16] parameter. See also getMatrix(). */
+void Quaternion::getInverseMatrix(GLdouble m[16]) const
+{
+  inverse().getMatrix(m);
+}
+
+/*! \p m is set to the 3x3 \e inverse rotation matrix associated with the Quaternion.
+
+ \attention This is the classical mathematical rotation matrix. The OpenGL format uses its
+ transposed version. See inverseMatrix() and getInverseMatrix(). */
+void Quaternion::getInverseRotationMatrix(float m[3][3]) const
+{
+  static GLdouble mat[4][4];
+  getInverseMatrix(mat);
+  for (int i=0; i<3; ++i)
+    for (int j=0; j<3; ++j)
+      // Beware of transposition
+      m[i][j] = mat[j][i];
+}
+
+
+/*! Returns the slerp interpolation of Quaternions \p a and \p b, at time \p t.
+
+ \p t should range in [0,1]. Result is \p a when \p t=0 and \p b when \p t=1.
+
+ When \p allowFlip is \c true (default) the slerp interpolation will always use the "shortest path"
+ between the Quaternions' orientations, by "flipping" the source Quaternion if needed (see
+ negate()). */
+Quaternion Quaternion::slerp(const Quaternion& a, const Quaternion& b, float t, bool allowFlip)
+{
+  float cosAngle = Quaternion::dot(a, b);
+
+  float c1, c2;
+  // Linear interpolation for close orientations
+  if ((1.0 - fabs(cosAngle)) < 0.01)
+    {
+      c1 = 1.0 - t;
+      c2 = t;
+    }
+  else
+    {
+      // Spherical interpolation
+      float angle    = acos(fabs(cosAngle));
+      float sinAngle = sin(angle);
+      c1 = sin(angle * (1.0 - t)) / sinAngle;
+      c2 = sin(angle * t) / sinAngle;
+    }
+
+  // Use the shortest path
+  if (allowFlip && (cosAngle < 0.0))
+    c1 = -c1;
+
+  return Quaternion(c1*a[0] + c2*b[0], c1*a[1] + c2*b[1], c1*a[2] + c2*b[2], c1*a[3] + c2*b[3]);
+}
+
+/*! Returns the slerp interpolation of the two Quaternions \p a and \p b, at time \p t, using
+  tangents \p tgA and \p tgB.
+
+  The resulting Quaternion is "between" \p a and \p b (result is \p a when \p t=0 and \p b for \p
+  t=1).
+
+  Use squadTangent() to define the Quaternion tangents \p tgA and \p tgB. */
+Quaternion Quaternion::squad(const Quaternion& a, const Quaternion& tgA, const Quaternion& tgB, const Quaternion& b, float t)
+{
+  Quaternion ab = Quaternion::slerp(a, b, t);
+  Quaternion tg = Quaternion::slerp(tgA, tgB, t, false);
+  return Quaternion::slerp(ab, tg, 2.0*t*(1.0-t), false);
+}
+
+/*! Returns the logarithm of the Quaternion. See also exp(). */
+Quaternion Quaternion::log()
+{
+  float len = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2]);
+
+  if (len < 1E-6)
+    return Quaternion(q[0], q[1], q[2], 0.0);
+  else
+    {
+      float coef = acos(q[3]) / len;
+      return Quaternion(q[0]*coef, q[1]*coef, q[2]*coef, 0.0);
+    }
+}
+
+/*! Returns the exponential of the Quaternion. See also log(). */
+Quaternion Quaternion::exp()
+{
+  float theta = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2]);
+
+  if (theta < 1E-6)
+    return Quaternion(q[0], q[1], q[2], cos(theta));
+  else
+    {
+      float coef = sin(theta) / theta;
+      return Quaternion(q[0]*coef, q[1]*coef, q[2]*coef, cos(theta));
+    }
+}
+
+/*! Returns log(a. inverse() * b). Useful for squadTangent(). */
+Quaternion Quaternion::lnDif(const Quaternion& a, const Quaternion& b)
+{
+  Quaternion dif = a.inverse()*b;
+  dif.normalize();
+  return dif.log();
+}
+
+/*! Returns a tangent Quaternion for \p center, defined by \p before and \p after Quaternions.
+
+ Useful for smooth spline interpolation of Quaternion with squad() and slerp(). */
+Quaternion Quaternion::squadTangent(const Quaternion& before, const Quaternion& center, const Quaternion& after)
+{
+  Quaternion l1 = Quaternion::lnDif(center,before);
+  Quaternion l2 = Quaternion::lnDif(center,after);
+  Quaternion e;
+  for (int i=0; i<4; ++i)
+    e.q[i] = -0.25 * (l1.q[i] + l2.q[i]);
+  e = center*(e.exp());
+
+  // if (Quaternion::dot(e,b) < 0.0)
+    // e.negate();
+
+  return e;
+}
+
+ostream& operator<<(ostream& o, const Quaternion& Q)
+{
+  return o << Q[0] << '\t' << Q[1] << '\t' << Q[2] << '\t' << Q[3];
+}
+
+/*! Returns a random unit Quaternion.
+
+You can create a randomly directed unit vector using:
+\code
+Vec randomDir = Quaternion::randomQuaternion() * Vec(1.0, 0.0, 0.0); // or any other Vec
+\endcode
+
+\note This function uses rand() to create pseudo-random numbers and the random number generator can
+be initialized using srand().*/
+Quaternion Quaternion::randomQuaternion()
+{
+  // The rand() function is not very portable and may not be available on your system.
+  // Add the appropriate include or replace by an other random function in case of problem.
+  double seed = rand()/(float)RAND_MAX;
+  double r1 = sqrt(1.0 - seed);
+  double r2 = sqrt(seed);
+  double t1 = 2.0 * M_PI * (rand()/(float)RAND_MAX);
+  double t2 = 2.0 * M_PI * (rand()/(float)RAND_MAX);
+  return Quaternion(sin(t1)*r1, cos(t1)*r1, sin(t2)*r2, cos(t2)*r2);
+}
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.h
new file mode 100644
index 00000000000..e6242e908b1
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_quaternion.h
@@ -0,0 +1,304 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_QUATERNION_H
+#define QGLVIEWER_QUATERNION_H
+
+#include "AppGLWidget_config.h"
+#include "AppGLWidget_vec.h"
+
+  /*! \brief The Quaternion class represents 3D rotations and orientations.
+  \class Quaternion quaternion.h QGLViewer/quaternion.h
+
+  The Quaternion is an appropriate (although not very intuitive) representation for 3D rotations and
+  orientations. Many tools are provided to ease the definition of a Quaternion: see constructors,
+  setAxisAngle(), setFromRotationMatrix(), setFromRotatedBasis().
+
+  You can apply the rotation represented by the Quaternion to 3D points using rotate() and
+  inverseRotate(). See also the Frame class that represents a coordinate system and provides other
+  conversion functions like Frame::coordinatesOf() and Frame::transformOf().
+
+  You can apply the Quaternion \c q rotation to the OpenGL matrices using:
+  \code
+  glMultMatrixd(q.matrix());
+  // equvalent to glRotate(q.angle()*180.0/M_PI, q.axis().x, q.axis().y, q.axis().z);
+  \endcode
+
+  Quaternion is part of the \c qglviewer namespace, specify \c qglviewer::Quaternion or use the qglviewer
+  namespace: \code using namespace qglviewer; \endcode
+
+  <h3>Internal representation</h3>
+
+  The internal representation of a Quaternion corresponding to a rotation around axis \c axis, with an angle
+  \c alpha is made of four doubles q[i]:
+  \code
+  {q[0],q[1],q[2]} = sin(alpha/2) * {axis[0],axis[1],axis[2]}
+  q[3] = cos(alpha/2)
+  \endcode
+
+  Note that certain implementations place the cosine term in first position (instead of last here).
+
+  The Quaternion is always normalized, so that its inverse() is actually its conjugate.
+
+  See also the Vec and Frame classes' documentations.
+  \nosubgrouping */
+class Quaternion
+{
+public:
+  /*! @name Defining a Quaternion */
+  //@{
+  /*! Default constructor, builds an identity rotation. */
+  Quaternion()
+  { q[0]=q[1]=q[2]=0.0;  q[3]=1.0; }
+
+  /*! Constructor from rotation axis (non null) and angle (in radians). See also setAxisAngle(). */
+  Quaternion(const Vec& axis, double angle)
+  {
+    setAxisAngle(axis, angle);
+  }
+
+  Quaternion(const Vec& from, const Vec& to);
+
+  /*! Constructor from the four values of a Quaternion. First three values are axis*sin(angle/2) and
+    last one is cos(angle/2).
+
+  \attention The identity Quaternion is Quaternion(0,0,0,1) and \e not Quaternion(0,0,0,0) (which is
+  not unitary). The default Quaternion() creates such identity Quaternion. */
+  Quaternion(double q0, double q1, double q2, double q3)
+  { q[0]=q0;    q[1]=q1;    q[2]=q2;    q[3]=q3; }
+
+  /*! Copy constructor. */
+  Quaternion(const Quaternion& Q)
+  { for (int i=0; i<4; ++i) q[i] = Q.q[i]; }
+
+  /*! Equal operator. */
+  Quaternion& operator=(const Quaternion& Q)
+  {
+    for (int i=0; i<4; ++i)
+      q[i] = Q.q[i];
+    return (*this);
+  }
+
+  /*! Sets the Quaternion as a rotation of axis \p axis and angle \p angle (in radians).
+
+  \p axis does not need to be normalized. A null \p axis will result in an identity Quaternion. */
+  void setAxisAngle(const Vec& axis, double angle)
+  {
+    const double norm = axis.norm();
+    if (norm < 1E-8)
+      {
+	// Null rotation
+	q[0] = 0.0;      q[1] = 0.0;      q[2] = 0.0;      q[3] = 1.0;
+      }
+    else
+      {
+	const double sin_half_angle = sin(angle / 2.0);
+	q[0] = sin_half_angle*axis[0]/norm;
+	q[1] = sin_half_angle*axis[1]/norm;
+	q[2] = sin_half_angle*axis[2]/norm;
+	q[3] = cos(angle / 2.0);
+      }
+  }
+
+  /*! Sets the Quaternion value. See the Quaternion(double, double, double, double) constructor documentation. */
+  void setValue(double q0, double q1, double q2, double q3)
+  { q[0]=q0;    q[1]=q1;    q[2]=q2;    q[3]=q3; }
+
+#ifndef DOXYGEN
+  void setFromRotationMatrix(const float m[3][3]);
+  void setFromRotatedBase(const Vec& X, const Vec& Y, const Vec& Z);
+#endif
+  void setFromRotationMatrix(const double m[3][3]);
+  void setFromRotatedBasis(const Vec& X, const Vec& Y, const Vec& Z);
+  //@}
+
+
+  /*! @name Accessing values */
+  //@{
+  Vec axis() const;
+  float angle() const;
+  void getAxisAngle(Vec& axis, float& angle) const;
+
+  /*! Bracket operator, with a constant return value. \p i must range in [0..3]. See the Quaternion(double, double, double, double) documentation. */
+  double operator[](int i) const { return q[i]; }
+
+  /*! Bracket operator returning an l-value. \p i must range in [0..3]. See the Quaternion(double, double, double, double) documentation. */
+  double& operator[](int i) { return q[i]; }
+  //@}
+
+
+  /*! @name Rotation computations */
+  //@{
+  /*! Returns the composition of the \p a and \p b rotations.
+
+  The order is important. When applied to a Vec \c v (see operator*(const Quaternion&, const Vec&)
+  and rotate()) the resulting Quaternion acts as if \p b was applied first and then \p a was
+  applied. This is obvious since the image \c v' of \p v by the composited rotation satisfies: \code
+  v'= (a*b) * v = a * (b*v) \endcode
+
+  Note that a*b usually differs from b*a.
+
+  \attention For efficiency reasons, the resulting Quaternion is not normalized. Use normalize() in
+  case of numerical drift with small rotation composition. */
+  friend Quaternion operator*(const Quaternion& a, const Quaternion& b)
+  {
+    return Quaternion(a.q[3]*b.q[0] + b.q[3]*a.q[0] + a.q[1]*b.q[2] - a.q[2]*b.q[1],
+		      a.q[3]*b.q[1] + b.q[3]*a.q[1] + a.q[2]*b.q[0] - a.q[0]*b.q[2],
+		      a.q[3]*b.q[2] + b.q[3]*a.q[2] + a.q[0]*b.q[1] - a.q[1]*b.q[0],
+		      a.q[3]*b.q[3] - b.q[0]*a.q[0] - a.q[1]*b.q[1] - a.q[2]*b.q[2]);
+  }
+
+  /*! Quaternion rotation is composed with \p q.
+
+  See operator*(), since this is equivalent to \c this = \c this * \p q.
+
+  \note For efficiency reasons, the resulting Quaternion is not normalized.
+  You may normalize() it after each application in case of numerical drift. */
+  Quaternion& operator*=(const Quaternion &q)
+  {
+    *this = (*this)*q;
+    return *this;
+  }
+
+  /*! Returns the image of \p v by the rotation \p q.
+
+  Same as q.rotate(v). See rotate() and inverseRotate(). */
+  friend Vec operator*(const Quaternion& q, const Vec& v)
+  {
+    return q.rotate(v);
+  }
+
+  Vec rotate(const Vec& v) const;
+  Vec inverseRotate(const Vec& v) const;
+  //@}
+
+
+  /*! @name Inversion */
+  //@{
+  /*! Returns the inverse Quaternion (inverse rotation).
+
+  Result has a negated axis() direction and the same angle(). A composition (see operator*()) of a
+  Quaternion and its inverse() results in an identity function.
+
+  Use invert() to actually modify the Quaternion. */
+  Quaternion inverse() const { return Quaternion(-q[0], -q[1], -q[2], q[3]); }
+
+  /*! Inverses the Quaternion (same rotation angle(), but negated axis()).
+
+  See also inverse(). */
+  void invert() { q[0] = -q[0]; q[1] = -q[1]; q[2] = -q[2]; }
+
+  /*! Negates all the coefficients of the Quaternion.
+
+  This results in an other representation of the \e same rotation (opposite rotation angle, but with
+  a negated axis direction: the two cancel out). However, note that the results of axis() and
+  angle() are unchanged after a call to this method since angle() always returns a value in [0,pi].
+
+  This method is mainly useful for Quaternion interpolation, so that the spherical
+  interpolation takes the shortest path on the unit sphere. See slerp() for details. */
+  void negate() { invert(); q[3] = -q[3]; }
+
+  /*! Normalizes the Quaternion coefficients.
+
+  This method should not need to be called since we only deal with unit Quaternions. This is however
+  useful to prevent numerical drifts, especially with small rotational increments. See also
+  normalized(). */
+  double normalize()
+  {
+    const double norm = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+    for (int i=0; i<4; ++i)
+      q[i] /= norm;
+    return norm;
+  }
+
+  /*! Returns a normalized version of the Quaternion.
+
+  See also normalize(). */
+  Quaternion normalized() const
+  {
+    double Q[4];
+    const double norm = sqrt(q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
+    for (int i=0; i<4; ++i)
+      Q[i] = q[i] / norm;
+    return Quaternion(Q[0], Q[1], Q[2], Q[3]);
+  }
+//@}
+
+
+  /*! @name Associated matrix */
+  //@{
+  const GLdouble* matrix() const;
+  void getMatrix(GLdouble m[4][4]) const;
+  void getMatrix(GLdouble m[16]) const;
+
+  void getRotationMatrix(float m[3][3]) const;
+
+  const GLdouble* inverseMatrix() const;
+  void getInverseMatrix(GLdouble m[4][4]) const;
+  void getInverseMatrix(GLdouble m[16]) const;
+
+  void getInverseRotationMatrix(float m[3][3]) const;
+  //@}
+
+
+  /*! @name Slerp interpolation */
+  //@{
+  static Quaternion slerp(const Quaternion& a, const Quaternion& b, float t, bool allowFlip=true);
+  static Quaternion squad(const Quaternion& a, const Quaternion& tgA, const Quaternion& tgB, const Quaternion& b, float t);
+  /*! Returns the "dot" product of \p a and \p b: a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]. */
+  static double dot(const Quaternion& a, const Quaternion& b) { return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]; }
+
+  Quaternion log();
+  Quaternion exp();
+  static Quaternion lnDif(const Quaternion& a, const Quaternion& b);
+  static Quaternion squadTangent(const Quaternion& before, const Quaternion& center, const Quaternion& after);
+  //@}
+
+  /*! @name Random Quaternion */
+  //@{
+  static Quaternion randomQuaternion();
+  //@}
+
+#ifdef DOXYGEN
+  /*! @name Output stream */
+  //@{
+  /*! Output stream operator. Enables debugging code like:
+  \code
+  Quaternion rot(...);
+  cout << "Rotation=" << rot << endl;
+  \endcode */
+  std::ostream& operator<<(std::ostream& o, const Vec&);
+  //@}
+#endif
+
+private:
+  /*! The internal data representation is private, use operator[] to access values. */
+  double q[4];
+};
+
+
+std::ostream& operator<<(std::ostream& o, const Quaternion&);
+
+#endif // QGLVIEWER_QUATERNION_H
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.cpp b/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.cpp
new file mode 100644
index 00000000000..2fad849238d
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.cpp
@@ -0,0 +1,75 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#include "AppGLWidget_vec.h"
+
+// Most of the methods are declared inline in vec.h
+using namespace std;
+
+/*! Projects the Vec on the axis of direction \p direction that passes through the origin.
+
+\p direction does not need to be normalized (but must be non null). */
+void Vec::projectOnAxis(const Vec& direction)
+{
+#ifndef QT_NO_DEBUG
+  if (direction.squaredNorm() < 1.0E-10)
+    cout << "Vec::projectOnAxis: axis direction is not normalized (norm=" << direction.norm() << ")." << endl;
+#endif
+
+  *this = (((*this)*direction) / direction.squaredNorm()) * direction;
+}
+
+/*! Projects the Vec on the plane whose normal is \p normal that passes through the origin.
+
+\p normal does not need to be normalized (but must be non null). */
+void Vec::projectOnPlane(const Vec& normal)
+{
+#ifndef QT_NO_DEBUG
+  if (normal.squaredNorm() < 1.0E-10)
+    cout << "Vec::projectOnPlane: plane normal is not normalized (norm=" << normal.norm() << ")." << endl;
+#endif
+
+  *this -= (((*this)*normal) / normal.squaredNorm()) * normal;
+}
+
+/*! Returns a Vec orthogonal to the Vec. Its norm() depends on the Vec, but is zero only for a
+ null Vec. Note that the function that associates an orthogonalVec() to a Vec is not continous. */
+Vec Vec::orthogonalVec() const
+{
+  // Find smallest component. Keep equal case for null values.
+  if ((fabs(y) >= 0.9*fabs(x)) && (fabs(z) >= 0.9*fabs(x)))
+    return Vec(0.0, -z, y);
+  else
+    if ((fabs(x) >= 0.9*fabs(y)) && (fabs(z) >= 0.9*fabs(y)))
+      return Vec(-z, 0.0, x);
+    else
+      return Vec(-y, x, 0.0);
+}
+
+ostream& operator<<(ostream& o, const Vec& v)
+{
+  return o << v.x << '\t' << v.y << '\t' << v.z;
+}
+
diff --git a/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.h b/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.h
new file mode 100644
index 00000000000..47643a19e8e
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/AppGLWidget_vec.h
@@ -0,0 +1,366 @@
+/****************************************************************************
+
+ Copyright (C) 2002-2007 Gilles Debunne (Gilles.Debunne@imag.fr)
+
+ This file is part of the QGLViewer library.
+ Version 2.2.6-3, released on August 28, 2007.
+
+ http://artis.imag.fr/Members/Gilles.Debunne/QGLViewer
+
+ libQGLViewer is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ libQGLViewer is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libQGLViewer; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*****************************************************************************/
+
+#ifndef QGLVIEWER_VEC_H
+#define QGLVIEWER_VEC_H
+
+#include "AppGLWidget_config.h"
+
+// #include <qapplication.h>
+
+// Included by all files as vec.h is at the end of the include hierarchy
+//soc #include "config.h" // Specific configuration options.
+
+/*! \brief The Vec class represents 3D positions and 3D vectors.
+  \class Vec vec.h QGLViewer/vec.h
+
+  Vec is used as a parameter and return type by many methods of the library. It provides classical
+  algebraic computational methods and is compatible with OpenGL:
+
+  \code
+  // Draws a point located at 3.0 OpenGL units in front of the camera
+  Vec pos = camera()->position() + 3.0 * camera()->viewDirection();
+  glBegin(GL_POINTS);
+  glVertex3fv(pos);
+  glEnd();
+  \endcode
+
+  This makes of Vec a good candidate for representing positions and vectors in your programs. Since
+  it is part of the \c qglviewer namespace, specify \c qglviewer::Vec or use the qglviewer
+  namespace:
+  \code
+  using namespace qglviewer;
+  \endcode
+
+  <h3>Interface with other vector classes</h3>
+
+  Vec implements a universal explicit converter, based on the \c [] \c operator.
+  Everywhere a \c const \c Vec& argument is expected, you can use your own vector type
+  instead, as long as it implements this operator (see the Vec(const C& c) documentation).
+
+  See also the Quaternion and the Frame documentations.
+  \nosubgrouping */
+class Vec
+{
+
+  // If your compiler complains the "The class "qglviewer::Vec" has no member "x"."
+  // Add your architecture Q_OS_XXXX flag (see qglobal.h) in this list.
+#if defined (Q_OS_IRIX) || defined (Q_OS_AIX) || defined (Q_OS_HPUX)
+# define QGLVIEWER_UNION_NOT_SUPPORTED
+#endif
+
+public:
+  /*! The internal data representation is public. One can use v.x, v.y, v.z. See also operator[](). */
+#if defined (DOXYGEN) || defined (QGLVIEWER_UNION_NOT_SUPPORTED)
+  float x, y, z;
+#else
+  union
+  {
+    struct { float x, y, z; };
+    float v_[3];
+  };
+#endif
+
+  /*! @name Setting the value */
+  //@{
+  /*! Default constructor. Value is set to (0,0,0). */
+  Vec() : x(0.0), y(0.0), z(0.0) {}
+
+  /*! Standard constructor with the x, y and z values. */
+  Vec(float X, float Y, float Z) : x(X), y(Y), z(Z) {}
+
+  /*! Universal explicit converter from any class to Vec. You can use your own vector class everywhere
+  a \c const \c Vec& parameter is required, as long as it implements the \c operator[ ]:
+
+  \code
+  class MyVec
+  {
+    // ...
+    float operator[](int i) const { returns x, y or z when i=0, 1 or 2; }
+  }
+
+  MyVec v(...);
+  camera()->setPosition(v);
+  \endcode
+
+  Note that standard vector types (stl, \c float[3], ...) implement this operator and can hence
+  be used in place of Vec. See also operator const float*() .*/
+  template <class C>
+  explicit Vec(const C& c) : x(c[0]), y(c[1]), z(c[2]) {}
+  // Should NOT be explicit to prevent conflicts with operator<<.
+
+  // ! Copy constructor
+  // Vec(const Vec& v) : x(v.x), y(v.y), z(v.z) {}
+
+  /*! Equal operator. */
+  Vec& operator=(const Vec& v)
+  {
+    x = v.x;   y = v.y;   z = v.z;
+    return *this;
+  }
+
+  /*! Set the current value. Maybe faster than using operator=() with a temporary Vec(x,y,z). */
+  void setValue(float X, float Y, float Z)
+  { x=X; y=Y; z=Z; }
+
+  // Universal equal operator which allows the use of any type in place of Vec,
+  // as long as the [] operator is implemented (v[0]=v.x, v[1]=v.y, v[2]=v.z).
+  // template <class C>
+  // Vec& operator=(const C& c)
+  // {
+  // x=c[0]; y=c[1]; z=c[2];
+  // return *this;
+  // }
+  //@}
+
+  /*! @name Accessing the value */
+  //@{
+  /*! Bracket operator, with a constant return value. \p i must range in [0..2]. */
+  float operator[](int i) const {
+#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
+    return (&x)[i];
+#else
+    return v_[i];
+#endif
+  }
+
+  /*! Bracket operator returning an l-value. \p i must range in [0..2]. */
+  float& operator[](int i) {
+#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
+    return (&x)[i];
+#else
+    return v_[i];
+#endif
+  }
+
+#ifndef DOXYGEN
+  /*! This method is deprecated since version 2.0. Use operator const float* instead. */
+  const float* address() const { cout << "Vec::address() is deprecated, use operator const float* instead." << endl; return operator const float*(); };
+#endif
+
+  /*! Conversion operator returning the memory address of the vector.
+
+  Very convenient to pass a Vec pointer as a parameter to OpenGL functions:
+  \code
+  Vec pos, normal;
+  glNormal3fv(normal);
+  glVertex3fv(pos);
+  \endcode */
+  operator const float*() const {
+#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
+    return &x;
+#else
+    return v_;
+#endif
+  }
+
+  /*! Non const conversion operator returning the memory address of the vector.
+
+  Useful to pass a Vec to a method that requires and fills a \c float*, as provided by certain libraries. */
+  operator float*() {
+#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
+    return &x;
+#else
+    return v_;
+#endif
+  }
+  //@}
+
+  /*! @name Algebraic computations */
+  //@{
+  /*! Returns the sum of the two vectors. */
+  friend Vec operator+(const Vec &a, const Vec &b)
+  {
+    return Vec(a.x+b.x, a.y+b.y, a.z+b.z);
+  }
+
+  /*! Returns the difference of the two vectors. */
+  friend Vec operator-(const Vec &a, const Vec &b)
+  {
+    return Vec(a.x-b.x, a.y-b.y, a.z-b.z);
+  }
+
+  /*! Unary minus operator. */
+  friend Vec operator-(const Vec &a)
+  {
+    return Vec(-a.x, -a.y, -a.z);
+  }
+
+  /*! Returns the product of the vector with a scalar. */
+  friend Vec operator*(const Vec &a, float k)
+  {
+    return Vec(a.x*k, a.y*k, a.z*k);
+  }
+
+  /*! Returns the product of the vector with a scalar. */
+  friend Vec operator*(float k, const Vec &a)
+  {
+    return a*k;
+  }
+
+  /*! Returns the division of the vector with a scalar.
+
+  Too small \p k values are \e not tested (unless the library was compiled with the "debug" Qt \c
+  CONFIG flag) and may result in \c NaN values. */
+  friend Vec operator/(const Vec &a, float k)
+  {
+#ifndef QT_NO_DEBUG
+    if (fabs(k) < 1.0E-10)
+		cout << "Vec::operator / : dividing by a null value" << endl;
+#endif
+    return Vec(a.x/k, a.y/k, a.z/k);
+  }
+
+  /*! Returns \c true only when the two vector are not equal (see operator==()). */
+  friend bool operator!=(const Vec &a, const Vec &b)
+  {
+    return !(a==b);
+  }
+
+  /*! Returns \c true when the squaredNorm() of the difference vector is lower than 1E-10. */
+  friend bool operator==(const Vec &a, const Vec &b)
+  {
+    const float epsilon = 1.0E-10f;
+    return (a-b).squaredNorm() < epsilon;
+  }
+
+  /*! Adds \p a to the vector. */
+  Vec& operator+=(const Vec &a)
+  {
+    x += a.x; y += a.y; z += a.z;
+    return *this;
+  }
+
+  /*! Subtracts \p a to the vector. */
+  Vec& operator-=(const Vec &a)
+  {
+    x -= a.x; y -= a.y; z -= a.z;
+    return *this;
+  }
+
+  /*! Multiply the vector by a scalar \p k. */
+  Vec& operator*=(float k)
+  {
+    x *= k; y *= k; z *= k;
+    return *this;
+  }
+
+  /*! Divides the vector by a scalar \p k.
+
+  An absolute \p k value lower than 1E-10 will print a warning if the library was compiled with the
+  "debug" Qt \c CONFIG flag. Otherwise, no test is performed for efficiency reasons. */
+  Vec& operator/=(float k)
+  {
+#ifndef QT_NO_DEBUG
+    if (fabs(k)<1.0E-10)
+		cout << "Vec::operator /= : dividing by a null value" << endl;
+#endif
+    x /= k; y /= k; z /= k;
+    return *this;
+  }
+
+  /*! Dot product of the two Vec. */
+  friend float operator*(const Vec &a, const Vec &b)
+  {
+    return a.x*b.x + a.y*b.y + a.z*b.z;
+  }
+
+  /*! Cross product of the two vectors. Same as cross(). */
+  friend Vec operator^(const Vec &a, const Vec &b)
+  {
+    return cross(a,b);
+  }
+
+  /*! Cross product of the two Vec. Mind the order ! */
+  friend Vec cross(const Vec &a, const Vec &b)
+  {
+    return Vec(a.y*b.z - a.z*b.y,
+	       a.z*b.x - a.x*b.z,
+	       a.x*b.y - a.y*b.x);
+  }
+
+  Vec orthogonalVec() const;
+  //@}
+
+  /*! @name Norm of the vector */
+  //@{
+#ifndef DOXYGEN
+  /*! This method is deprecated since version 2.0. Use squaredNorm() instead. */
+  float sqNorm() const { return x*x + y*y + z*z; }
+#endif
+
+  /*! Returns the \e squared norm of the Vec. */
+  float squaredNorm() const { return x*x + y*y + z*z; }
+
+  /*! Returns the norm of the vector. */
+  float norm() const { return sqrt(x*x + y*y + z*z); }
+
+  /*! Normalizes the Vec and returns its original norm.
+
+  Normalizing a null vector will result in \c NaN values. */
+  float normalize()
+  {
+    const float n = norm();
+#ifndef QT_NO_DEBUG
+    if (n < 1.0E-10)
+		cout << "Vec::normalize: normalizing a null vector" << endl;
+#endif
+    *this /= n;
+    return n;
+  }
+
+  /*! Returns a unitary (normalized) \e representation of the vector. The original Vec is not modified. */
+  Vec unit() const
+  {
+    Vec v = *this;
+    v.normalize();
+    return v;
+  }
+  //@}
+
+  /*! @name Projection */
+  //@{
+  void projectOnAxis(const Vec& direction);
+  void projectOnPlane(const Vec& normal);
+  //@}
+
+
+#ifdef DOXYGEN
+  /*! @name Output stream */
+  //@{
+  /*! Output stream operator. Enables debugging code like:
+  \code
+  Vec pos(...);
+  cout << "Position=" << pos << endl;
+  \endcode */
+  std::ostream& operator<<(std::ostream& o, const qglviewer::Vec&);
+  //@}
+#endif
+};
+
+
+std::ostream& operator<<(std::ostream& o, const Vec&);
+
+#endif // QGLVIEWER_VEC_H
diff --git a/source/blender/freestyle/intern/app_blender/Controller.cpp b/source/blender/freestyle/intern/app_blender/Controller.cpp
new file mode 100755
index 00000000000..e2cc25c4b10
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/Controller.cpp
@@ -0,0 +1,1097 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Must be included before any QT header, because of moc
+#include "../system/PythonInterpreter.h"
+
+#include <string>
+#include <fstream>
+#include <float.h>
+
+#include "AppGLWidget.h"
+#include "AppCanvas.h"
+#include "AppConfig.h"
+
+
+#include "../system/StringUtils.h"
+#include "../scene_graph/MaxFileLoader.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/NodeTransform.h"
+#include "../scene_graph/NodeDrawingStyle.h"
+#include "../winged_edge/WingedEdgeBuilder.h"
+#include "../winged_edge/WEdge.h"
+#include "../scene_graph/VertexRep.h"
+#include "../winged_edge/WXEdgeBuilder.h"
+#include "../scene_graph/ScenePrettyPrinter.h"
+#include "../winged_edge/WFillGrid.h"
+
+#include "../view_map/ViewMapTesselator.h"
+#include "../stroke/StrokeTesselator.h"
+#include "../view_map/ViewMapIO.h"
+#include "Controller.h"
+#include "../view_map/ViewMap.h"
+#include "../winged_edge/Curvature.h"
+//#include "QGLBasicWidget.h"
+//#include <qimage.h>
+#include "../image/Image.h"
+#include "../view_map/SteerableViewMap.h"
+#include "../stroke/PSStrokeRenderer.h"
+#include "../stroke/TextStrokeRenderer.h"
+#include "../stroke/StyleModule.h"
+
+#ifndef WIN32
+//# include "GLXOffscreenBuffer.h"
+//# include "GLXOffscreenBuffer.h"
+#endif
+
+#include "../system/StringUtils.h"
+
+Controller::Controller()
+{
+	
+  const string sep(Config::DIR_SEP.c_str());
+  //const string filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR + sep + Config::OPTIONS_CURRENT_DIRS_FILE;
+  //_current_dirs = new ConfigIO(filename, Config::APPLICATION_NAME + "CurrentDirs", true);
+
+  _RootNode = new NodeGroup;
+  _RootNode->addRef();
+  
+  _SilhouetteNode = NULL;
+  //_ProjectedSilhouette = NULL;
+  //_VisibleProjectedSilhouette = NULL;
+  
+  _DebugNode = new NodeGroup;
+  _DebugNode->addRef();
+
+  _winged_edge = NULL;
+  
+  _pView = NULL;
+
+  _edgeTesselationNature = (Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE);
+
+  _ProgressBar = new ProgressBar;
+  _SceneNumFaces = 0;
+  _minEdgeSize = DBL_MAX;
+  _bboxDiag = 0;
+  
+  _ViewMap = 0;
+
+  _Canvas = 0;
+
+  _VisibilityAlgo = ViewMapBuilder::ray_casting;
+  //_VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+
+  _Canvas = new AppCanvas;
+
+  _inter = new PythonInterpreter;
+  _EnableQI = true;
+  _ComputeRidges = true;
+  _ComputeSteerableViewMap = false;
+  _ComputeSuggestive = true;
+  _sphereRadius = 1.0;
+
+	init_options();
+}
+
+Controller::~Controller()
+{
+  if(NULL != _RootNode)
+    {
+      int ref = _RootNode->destroy();
+      if(0 == ref)
+	delete _RootNode;
+    }
+  
+  if(NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	delete _SilhouetteNode;
+    }
+  
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	delete _DebugNode;
+    }
+
+  if(_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
+
+  if(0 != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  if(0 != _Canvas)
+    {
+      delete _Canvas;
+      _Canvas = 0;
+    }
+
+  if (_inter) {
+    delete _inter;
+    _inter = NULL;
+  }
+
+  //delete _current_dirs;
+}
+
+void Controller::setView(AppGLWidget *iView)
+{
+  if(NULL == iView)
+    return;
+  
+  _pView = iView;
+  _Canvas->setViewer(_pView);
+}
+
+
+int Controller::Load3DSFile(const char *iFileName)
+{
+  if (_pView)
+    _pView->setUpdateMode(false);
+  
+  MaxFileLoader loader3DS(iFileName);
+  //_RootNode->AddChild(BuildSceneTest());
+  
+  _Chrono.start();
+  
+  NodeGroup *maxScene = loader3DS.Load();
+
+  if (maxScene == NULL) {
+	cout << "Cannot load scene" << endl;
+    return 1;
+  }
+
+  cout << "Scene loaded\n" << endl;
+
+  printf("Mesh cleaning    : %lf\n", _Chrono.stop());
+  _SceneNumFaces += loader3DS.numFacesRead();
+
+  if(loader3DS.minEdgeSize() < _minEdgeSize)
+    {
+      _minEdgeSize = loader3DS.minEdgeSize();
+      _EPSILON = _minEdgeSize*1e-6;
+      if(_EPSILON < DBL_MIN)
+	_EPSILON = 0.0;
+    }
+
+  cout << "Epsilon computed : " << _EPSILON << endl;
+
+  // DEBUG
+//   ScenePrettyPrinter spp;
+//   maxScene->accept(spp);
+	
+  _RootNode->AddChild(maxScene);
+  _RootNode->UpdateBBox(); // FIXME: Correct that by making a Renderer to compute the bbox
+
+  _pView->setModel(_RootNode);
+  //_pView->FitBBox();
+
+
+  _Chrono.start();
+
+  
+  WXEdgeBuilder wx_builder;
+  maxScene->accept(wx_builder);
+  _winged_edge = wx_builder.getWingedEdge();
+
+  printf("WEdge building   : %lf\n", _Chrono.stop());
+
+ _Chrono.start();
+
+  _Grid.clear();
+  Vec3r size;
+  for(unsigned int i=0; i<3; i++)
+    {
+      size[i] = fabs(_RootNode->bbox().getMax()[i] - _RootNode->bbox().getMin()[i]);
+      size[i] += size[i]/10.0; // let make the grid 1/10 bigger to avoid numerical errors while computing triangles/cells intersections
+      if(size[i]==0){
+          cout << "Warning: the bbox size is 0 in dimension "<<i<<endl;
+      }
+    }
+  _Grid.configure(Vec3r(_RootNode->bbox().getMin() - size / 20.0), size,
+		  _SceneNumFaces);
+
+  // Fill in the grid:
+  WFillGrid fillGridRenderer(&_Grid, _winged_edge);
+  fillGridRenderer.fillGrid();
+
+  printf("Grid building    : %lf\n", _Chrono.stop());
+  
+  // DEBUG
+//   _Grid.displayDebug();
+   
+  _pView->setDebug(_DebugNode);
+
+  //delete stuff
+  //  if(0 != ws_builder)
+  //    {
+  //      delete ws_builder;
+  //      ws_builder = 0;
+  //    }
+  _pView->updateGL();
+  
+
+	//soc QFileInfo qfi(iFileName);
+	//soc string basename((const char*)qfi.fileName().toAscii().data());
+	char cleaned[FILE_MAX];
+	BLI_strncpy(cleaned, iFileName, FILE_MAX);
+	BLI_cleanup_file(NULL, cleaned);
+	string basename = StringUtils::toAscii( string(cleaned) );
+
+  _ListOfModels.push_back(basename);
+
+  cout << "Triangles nb     : " << _SceneNumFaces << endl;
+  _bboxDiag = (_RootNode->bbox().getMax()-_RootNode->bbox().getMin()).norm();
+  cout << "Bounding Box     : " << _bboxDiag << endl;
+  return 0;
+}
+
+void Controller::CloseFile()
+{
+  WShape::setCurrentId(0);
+  _pView->DetachModel();
+  _ListOfModels.clear();
+  if(NULL != _RootNode)
+    {
+      int ref = _RootNode->destroy();
+      if(0 == ref)
+	_RootNode->addRef();
+    
+      _RootNode->clearBBox();
+    }
+  
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	{
+	  delete _SilhouetteNode;
+	  _SilhouetteNode = NULL;
+	}
+    }
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _ProjectedSilhouette;
+  //	  _ProjectedSilhouette = NULL;
+  //	}
+  //    }
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _VisibleProjectedSilhouette;
+  //	  _VisibleProjectedSilhouette = NULL;
+  //	}
+  //  }
+  
+  _pView->DetachDebug();
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	_DebugNode->addRef();
+    }
+  
+  if(_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
+
+  // We deallocate the memory:
+  if(NULL != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  // clears the canvas
+  _Canvas->Erase();
+
+  // clears the grid
+  _Grid.clear();
+  _SceneNumFaces = 0;
+  _minEdgeSize = DBL_MAX;
+  //  _pView2D->DetachScene();
+  //  if(NULL != _SRoot)
+  //  {
+  //    int ref = _SRoot->destroy();
+  //    if(0 == ref)
+  //    {
+  //      //_SRoot->addRef();
+  //      delete _SRoot;
+  //      _SRoot = NULL;
+  //    }
+  //  }
+}
+
+//  static const streamsize buffer_size = 512 * 1024;
+
+void Controller::SaveViewMapFile(const char *oFileName)
+{
+  if (!_ViewMap)
+    return;
+
+  ofstream ofs(oFileName, ios::binary);
+  if (!ofs.is_open()) {
+    cerr << "Error: Cannot save this file" << endl;
+    return;
+  }
+//    char buffer[buffer_size];
+//  #if defined(__GNUC__) && (__GNUC__ < 3)
+//    ofs.rdbuf()->setbuf(buffer, buffer_size);
+//  # else
+//    ofs.rdbuf()->pubsetbuf(buffer, buffer_size);
+//  #endif
+  _Chrono.start();
+
+  ofs << Config::VIEWMAP_MAGIC << endl << Config::VIEWMAP_VERSION << endl;
+
+  // Write the models filenames
+  ofs << _ListOfModels.size() << endl;
+  for (vector<string>::const_iterator i = _ListOfModels.begin(); i != _ListOfModels.end(); i++)
+    ofs << *i << "\n";
+
+  // Save the camera position
+  float position[3];
+  float orientation[4];
+  _pView->getCameraState(position, orientation);
+  ofs.write((char*)position, 3 * sizeof(*position));
+  ofs.write((char*)orientation, 4 * sizeof(*orientation));
+
+  // Write ViewMap
+  if (ViewMapIO::save(ofs, _ViewMap, 0)) {
+    _Chrono.stop();
+    cerr << "Error: Cannot save this file" << endl;
+    return;
+  }
+
+  real d = _Chrono.stop();
+  cout << "ViewMap saving   : " << d << endl;
+}
+
+// void Controller::LoadViewMapFile(const char *iFileName, bool only_camera)
+// {
+//   ifstream ifs(iFileName, ios::binary);
+//   if (!ifs.is_open()) {
+//     cerr << "Error: Cannot load this file" << endl;
+//     return;
+//   }
+// //    char buffer[buffer_size];
+// //  #if defined(__GNUC__) && (__GNUC__ < 3)
+// //    ifs.rdbuf()->setbuf(buffer, buffer_size);
+// //  # else
+// //    ifs.rdbuf()->pubsetbuf(buffer, buffer_size);
+// //  #endif
+// 
+//   // Test File Magic and version
+//   char tmp_buffer[256];
+//   string test;
+//   
+//   ifs.getline(tmp_buffer, 255);
+//   test = tmp_buffer;
+//   if (test != Config::VIEWMAP_MAGIC) {
+//     cerr << "Error: This is not a valid ." << Config::VIEWMAP_EXTENSION << " file" << endl;
+//     return;
+//   }
+//   ifs.getline(tmp_buffer, 255);
+//   test = tmp_buffer;
+//   if (test != Config::VIEWMAP_VERSION && !only_camera) {
+//     cerr << "Error: This version of the ." << Config::VIEWMAP_EXTENSION << " file format is no longer supported" << endl;
+//     return;
+//   }
+// 
+//   // Read the models filenames and open them (if not already done)
+//   string tmp;
+//   vector<string> tmp_vec;
+//   unsigned models_nb, i;
+// 
+//   ifs.getline(tmp_buffer, 255);
+//   models_nb = atoi(tmp_buffer);
+//   for (i = 0; i < models_nb; i++) {
+//     ifs.getline(tmp_buffer, 255);
+//     tmp = tmp_buffer;
+//     tmp_vec.push_back(tmp);
+//   }
+//   if (_ListOfModels != tmp_vec && !only_camera) {
+//     CloseFile();
+//     vector<string> pathnames;
+//     int err = 0;
+//     for (vector<string>::const_iterator i = tmp_vec.begin(); i != tmp_vec.end(); i++)
+//       {
+// 	pathnames.clear();
+// 	StringUtils::getPathName(ViewMapIO::Options::getModelsPath(), *i, pathnames);
+// 	for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++)
+// 	  if (!(err = Load3DSFile(j->c_str())))
+// 	    break;
+// 	if (err) {
+// 	  cerr << "Error: cannot find model \"" << *i << "\" - check the path in the Options" << endl;
+// 	  return;
+// 	}
+//       }
+//   }
+// 
+//   // set the camera position
+//   float position[3];
+//   float orientation[4];
+//   ifs.read((char*)position, 3 * sizeof(*position));
+//   ifs.read((char*)orientation, 4 * sizeof(*orientation));
+//   _pView->setCameraState(position, orientation);
+//   _pView->saveCameraState();
+// 
+//   if (only_camera) {
+//     return;
+//   }
+// 
+//   // Reset ViewMap
+//   if(NULL != _ViewMap)
+//     {
+//       delete _ViewMap;
+//       _ViewMap = 0;
+//     }
+//   _pView->DetachSilhouette();
+//   if (NULL != _SilhouetteNode)
+//     {
+//       int ref = _SilhouetteNode->destroy();
+//       if(0 == ref)
+// 	delete _SilhouetteNode;
+//     }
+//   //  if(NULL != _ProjectedSilhouette)
+//   //    {
+//   //      int ref = _ProjectedSilhouette->destroy();
+//   //      if(0 == ref)
+//   //	delete _ProjectedSilhouette;
+//   //    }
+//   //  if(NULL != _VisibleProjectedSilhouette)
+//   //    {
+//   //      int ref = _VisibleProjectedSilhouette->destroy();
+//   //      if(0 == ref)
+//   //	{
+//   //	  delete _VisibleProjectedSilhouette;
+//   //	  _VisibleProjectedSilhouette = 0;
+//   //	}
+//    // }
+//   _ViewMap = new ViewMap();
+// 
+//   // Read ViewMap
+//   _Chrono.start();
+//   if (ViewMapIO::load(ifs, _ViewMap, 0)) {
+//     _Chrono.stop();
+// 
+//     cerr << "Error: This is not a valid ." << Config::VIEWMAP_EXTENSION << " file" << endl;
+//     return;
+//   }
+// 
+//   // Update display
+//   ViewMapTesselator3D sTesselator3d;
+//   //ViewMapTesselator2D sTesselator2d;
+//   //sTesselator2d.setNature(_edgeTesselationNature);
+//   sTesselator3d.setNature(_edgeTesselationNature);
+//   
+//   // Tesselate the 3D edges:
+//   _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
+//   _SilhouetteNode->addRef();
+//   
+//   // Tesselate 2D edges
+//   //  _ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
+//   //  _ProjectedSilhouette->addRef();
+//   //  
+//   _pView->AddSilhouette(_SilhouetteNode);
+//   //_pView->Add2DSilhouette(_ProjectedSilhouette);
+// 
+//   // Update options window
+//   //_pOptionsWindow->updateViewMapFormat();
+// 
+//   real d = _Chrono.stop();
+//   cout << "ViewMap loading  : " << d << endl;
+// 
+//   // Compute the Directional ViewMap:
+//   if(_ComputeSteerableViewMap){
+//     ComputeSteerableViewMap();
+//   }
+// 
+//   // Reset Style modules modification flags
+//   resetModified(true);
+// }
+
+void Controller::ComputeViewMap()
+{
+
+  if (!_ListOfModels.size())
+    return;
+  
+  if(NULL != _ViewMap)
+    {
+      delete _ViewMap;
+      _ViewMap = 0;
+    }
+
+  _pView->DetachDebug();
+  if(NULL != _DebugNode)
+    {
+      int ref = _DebugNode->destroy();
+      if(0 == ref)
+	_DebugNode->addRef();
+    }
+  
+
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode)
+    {
+      int ref = _SilhouetteNode->destroy();
+      if(0 == ref)
+	delete _SilhouetteNode;
+    }
+  //  if(NULL != _ProjectedSilhouette)
+  //    {
+  //      int ref = _ProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	delete _ProjectedSilhouette;
+  //    }
+  //  if(NULL != _VisibleProjectedSilhouette)
+  //    {
+  //      int ref = _VisibleProjectedSilhouette->destroy();
+  //      if(0 == ref)
+  //	{
+  //	  delete _VisibleProjectedSilhouette;
+  //	  _VisibleProjectedSilhouette = 0;
+  //	}
+  //  }
+  
+  // retrieve the 3D viewpoint and transformations information
+  //----------------------------------------------------------
+  // Save the viewpoint context at the view level in order 
+  // to be able to restore it later:
+  _pView->saveCameraState();
+
+  // Restore the context of view:
+  // we need to perform all these operations while the 
+  // 3D context is on.
+  _pView->set3DContext();
+  float src[3] = { 0, 0, 0 };
+  float vp_tmp[3] = { 0, 0, 0 };
+  _pView->_camera->getWorldCoordinatesOf(src, vp_tmp);
+  Vec3r vp(vp_tmp[0], vp_tmp[1], vp_tmp[2]);
+
+  real mv[4][4];
+  _pView->RetriveModelViewMatrix((real *)mv);
+  // retrieve the projection matrix:
+  real proj[4][4];
+  _pView->RetrieveProjectionMatrix((real *)proj);
+  int viewport[4];
+  _pView->RetrieveViewport(viewport);  
+  real focalLength = _pView->GetFocalLength();
+
+  // Flag the WXEdge structure for silhouette edge detection:
+  //----------------------------------------------------------
+
+  _Chrono.start();
+ 
+  edgeDetector.setViewpoint(Vec3r(vp));
+  edgeDetector.enableRidgesAndValleysFlag(_ComputeRidges);
+  edgeDetector.enableSuggestiveContours(_ComputeSuggestive);
+  edgeDetector.setSphereRadius(_sphereRadius);
+  edgeDetector.setSuggestiveContourKrDerivativeEpsilon(_suggestiveContourKrDerivativeEpsilon);
+  edgeDetector.processShapes(*_winged_edge);
+
+  real duration = _Chrono.stop();
+  printf("Feature lines    : %lf\n", duration);
+
+  // Builds the view map structure from the flagged WSEdge structure:
+  //----------------------------------------------------------
+  ViewMapBuilder vmBuilder;
+  vmBuilder.setEnableQI(_EnableQI);
+  vmBuilder.setViewpoint(Vec3r(vp));
+  
+  vmBuilder.setTransform(mv, proj, viewport, focalLength, _pView->GetAspect(), _pView->GetFovyRadian());
+  vmBuilder.setFrustum(_pView->znear(), _pView->zfar());
+  
+  vmBuilder.setGrid(&_Grid);
+  
+  // Builds a tesselated form of the silhouette for display purpose:
+  //---------------------------------------------------------------
+  ViewMapTesselator3D sTesselator3d;
+  //ViewMapTesselator2D sTesselator2d;
+  //sTesselator2d.setNature(_edgeTesselationNature);
+  sTesselator3d.setNature(_edgeTesselationNature);
+    
+  _Chrono.start();
+  // Build View Map
+  _ViewMap = vmBuilder.BuildViewMap(*_winged_edge, _VisibilityAlgo, _EPSILON);
+  _ViewMap->setScene3dBBox(_RootNode->bbox());
+  
+  //Tesselate the 3D edges:
+  _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
+  _SilhouetteNode->addRef();
+  
+  // Tesselate 2D edges
+  //  _ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
+  //  _ProjectedSilhouette->addRef();
+  
+  duration = _Chrono.stop();
+  printf("ViewMap building : %lf\n", duration);
+
+  
+  _pView->AddSilhouette(_SilhouetteNode);
+  //_pView->AddSilhouette(_WRoot);
+  //_pView->Add2DSilhouette(_ProjectedSilhouette);
+  //_pView->Add2DVisibleSilhouette(_VisibleProjectedSilhouette);  
+  _pView->AddDebug(_DebugNode);
+
+  // Draw the steerable density map:
+  //--------------------------------
+  if(_ComputeSteerableViewMap){
+    ComputeSteerableViewMap();
+  }
+  // Reset Style modules modification flags
+  resetModified(true);
+}
+
+void Controller::ComputeSteerableViewMap(){
+//soc
+  // if((!_Canvas) || (!_ViewMap))
+  //   return;
+  //   
+  // // Build 4 nodes containing the edges in the 4 directions
+  // NodeGroup *ng[Canvas::NB_STEERABLE_VIEWMAP];
+  // unsigned i;
+  // real c = 32.f/255.f; // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
+  // for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP; ++i){
+  //   ng[i] = new NodeGroup;
+  // }
+  // NodeShape *completeNS = new NodeShape;
+  // completeNS->material().setDiffuse(c,c,c,1);
+  // ng[Canvas::NB_STEERABLE_VIEWMAP-1]->AddChild(completeNS);
+  // SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  // svm->Reset();
+  // 
+  // ViewMap::fedges_container& fedges = _ViewMap->FEdges();
+  // LineRep * fRep;
+  // NodeShape *ns;
+  // for(ViewMap::fedges_container::iterator f=fedges.begin(), fend=fedges.end();
+  // f!=fend;
+  // ++f){
+  //   if((*f)->viewedge()->qi() != 0)
+  //     continue;
+  //   fRep = new LineRep((*f)->vertexA()->point2d(),(*f)->vertexB()->point2d()) ;
+  //   completeNS->AddRep(fRep); // add to the complete map anyway
+  //   double *oweights = svm->AddFEdge(*f);
+  //   for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP-1; ++i){
+  //     ns = new NodeShape;
+  //     double wc = oweights[i]*c;
+  //     if(oweights[i] == 0)
+  //       continue;
+  //     ns->material().setDiffuse(wc, wc, wc, 1);
+  //     ns->AddRep(fRep);
+  //     ng[i]->AddChild(ns);
+  //   }
+  // }
+  // 
+  // GrayImage *img[Canvas::NB_STEERABLE_VIEWMAP];
+  // //#ifdef WIN32
+  // QGLBasicWidget offscreenBuffer(_pView, "SteerableViewMap", _pView->width(), _pView->height()); 
+  // QPixmap pm;
+  // QImage qimg;
+  // for(i=0; i<Canvas::NB_STEERABLE_VIEWMAP; ++i){
+  //   offscreenBuffer.AddNode(ng[i]);
+  //   //img[i] = new GrayImage(_pView->width(), _pView->height());
+  //   //offscreenBuffer.readPixels(0,0,_pView->width(), _pView->height(), img[i]->getArray());
+  //   pm = offscreenBuffer.renderPixmap(_pView->width(), _pView->height());
+  // 
+  //   if(pm.isNull())
+  //     cout << "BuildViewMap Warning: couldn't render the steerable ViewMap" << endl;
+  //   //pm.save(QString("steerable")+QString::number(i)+QString(".bmp"), "BMP");
+  //   // FIXME!! Lost of time !
+  //   qimg = pm.toImage();
+  //   // FIXME !! again!
+  //   img[i] = new GrayImage(_pView->width(), _pView->height());
+  //   for(unsigned y=0;y<img[i]->height();++y){
+  //     for(unsigned x=0;x<img[i]->width();++x){
+  //       //img[i]->setPixel(x,y,(float)qGray(qimg.pixel(x,y))/255.f);
+  //       img[i]->setPixel(x,y,(float)qGray(qimg.pixel(x,y)));
+  //       //        float c = qGray(qimg.pixel(x,y));
+  //       //        img[i]->setPixel(x,y,qGray(qimg.pixel(x,y)));
+  //     }
+  //   }
+  //   offscreenBuffer.DetachNode(ng[i]);
+  //   ng[i]->destroy();
+  //   delete ng[i];
+  //   // check
+  //   //    qimg = QImage(_pView->width(), _pView->height(), 32);
+  //   //    for(y=0;y<img[i]->height();++y){
+  //   //      for(unsigned x=0;x<img[i]->width();++x){
+  //   //        float v = img[i]->pixel(x,y);
+  //   //        qimg.setPixel(x,y,qRgb(v,v,v));
+  //   //      }
+  //   //    }
+  //   //    qimg.save(QString("newsteerable")+QString::number(i)+QString(".bmp"), "BMP");
+  // }
+  // 
+  // 
+  // svm->buildImagesPyramids(img,false,0,1.f);
+}
+
+void Controller::saveSteerableViewMapImages(){
+  SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  if(!svm){
+    cerr << "the Steerable ViewMap has not been computed yet" << endl;
+    return;
+  }
+  svm->saveSteerableViewMap();
+}
+
+void Controller::toggleVisibilityAlgo() 
+{
+  if(_VisibilityAlgo == ViewMapBuilder::ray_casting) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+  }
+  else if (_VisibilityAlgo == ViewMapBuilder::ray_casting_fast) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
+  }
+  else {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting;
+  }
+}
+
+void Controller::setQuantitativeInvisibility(bool iBool)
+{
+  _EnableQI = iBool;
+}
+
+bool Controller::getQuantitativeInvisibility() const
+{
+  return _EnableQI;
+}
+
+void Controller::setComputeRidgesAndValleysFlag(bool iBool){
+  _ComputeRidges = iBool;
+}
+
+bool Controller::getComputeRidgesAndValleysFlag() const {
+  return _ComputeRidges;
+}
+void Controller::setComputeSuggestiveContoursFlag(bool b){
+  _ComputeSuggestive = b;
+}
+  
+bool Controller::getComputeSuggestiveContoursFlag() const {
+  return _ComputeSuggestive;
+}
+void Controller::setComputeSteerableViewMapFlag(bool iBool){
+  _ComputeSteerableViewMap = iBool;
+}
+
+bool Controller::getComputeSteerableViewMapFlag() const {
+  return _ComputeSteerableViewMap;
+}
+void Controller::setFrontBufferFlag(bool iBool)
+{
+  AppGLWidget::setFrontBufferFlag(iBool);
+}
+
+bool Controller::getFrontBufferFlag() const
+{
+  return AppGLWidget::getFrontBufferFlag();
+}
+
+void Controller::setBackBufferFlag(bool iBool)
+{
+  AppGLWidget::setBackBufferFlag(iBool);
+}
+
+bool Controller::getBackBufferFlag() const
+{
+  return AppGLWidget::getBackBufferFlag();
+}
+
+void Controller::DrawStrokes()
+{
+  if(_ViewMap == 0)
+    return;
+
+  _Chrono.start();
+  _Canvas->Draw();
+  real d = _Chrono.stop();
+  cout << "Strokes drawing  : " << d << endl;
+  resetModified();
+}
+
+void Controller::InsertStyleModule(unsigned index, const char *iFileName)
+{
+  // QFileInfo fi(iFileName);
+  // string ext = fi.suffix();
+  // if (ext != "py") {
+  //   cerr << "Error: Cannot load \"" << fi.fileName().toAscii().data()
+  // 	 << "\", unknown extension" << endl;
+  //   return;
+  // }
+
+	if( !BLI_testextensie(iFileName, ".py") ) {
+		cerr << "Error: Cannot load \"" << StringUtils::toAscii( string(iFileName) )
+		  << "\", unknown extension" << endl;
+		  return;
+	}
+
+  StyleModule* sm = new StyleModule(iFileName, _inter);
+  _Canvas->InsertStyleModule(index, sm);
+  
+}
+
+void Controller::AddStyleModule(const char *iFileName)
+{
+  //_pStyleWindow->Add(iFileName);
+}
+
+void Controller::RemoveStyleModule(unsigned index)
+{
+  _Canvas->RemoveStyleModule(index);
+}
+
+void Controller::Clear()
+{
+  _Canvas->Clear();
+}
+
+void Controller::ReloadStyleModule(unsigned index, const char * iFileName)
+{
+  StyleModule* sm = new StyleModule(iFileName, _inter);
+  _Canvas->ReplaceStyleModule(index, sm);
+}
+
+void Controller::SwapStyleModules(unsigned i1, unsigned i2)
+{
+  _Canvas->SwapStyleModules(i1, i2);
+}
+
+
+void Controller::toggleLayer(unsigned index, bool iDisplay)
+{
+  _Canvas->setVisible(index, iDisplay);
+  _pView->updateGL();
+}
+
+void Controller::setModified(unsigned index, bool iMod)
+{
+  //_pStyleWindow->setModified(index, iMod);
+  _Canvas->setModified(index, iMod);
+  updateCausalStyleModules(index + 1);
+}
+
+void Controller::updateCausalStyleModules(unsigned index) {
+  vector<unsigned> vec;
+  _Canvas->causalStyleModules(vec, index);
+  for (vector<unsigned>::const_iterator it = vec.begin(); it != vec.end(); it++) {
+    //_pStyleWindow->setModified(*it, true);
+    _Canvas->setModified(*it, true);
+  }
+}
+
+void Controller::saveSnapshot(bool b) {
+ _pView->saveSnapshot(b);
+}
+
+void Controller::resetModified(bool iMod)
+{
+  //_pStyleWindow->resetModified(iMod);
+  _Canvas->resetModified(iMod);
+}
+
+FEdge* Controller::SelectFEdge(real x, real y)
+{
+  if (!_ViewMap)
+    return NULL;
+
+  FEdge *fedge = (FEdge*)_ViewMap->GetClosestFEdge(x,y);
+  //ViewEdge *selection = fedge->viewedge();
+  _pView->setSelectedFEdge(fedge);
+  _Canvas->setSelectedFEdge(fedge);
+  return fedge;
+}
+
+ViewEdge* Controller::SelectViewEdge(real x, real y)
+{
+  if (!_ViewMap)
+    return NULL;
+
+  FEdge *fedge = (FEdge*)_ViewMap->GetClosestFEdge(x,y);
+  ViewEdge *selection = fedge->viewedge();
+  _pView->setSelectedFEdge(fedge);
+  _Canvas->setSelectedFEdge(fedge);
+  return selection;
+}
+
+NodeGroup * Controller::BuildRep(vector<ViewEdge*>::iterator vedges_begin, 
+                                       vector<ViewEdge*>::iterator vedges_end)
+{
+  ViewMapTesselator2D tesselator2D;
+  Material mat;
+  mat.setDiffuse(1,1,0.3,1);
+  tesselator2D.setMaterial(mat);
+
+  return (tesselator2D.Tesselate(vedges_begin, vedges_end));
+}
+
+void Controller::toggleEdgeTesselationNature(Nature::EdgeNature iNature)
+{
+  _edgeTesselationNature ^= (iNature);
+  ComputeViewMap();
+}
+
+void		Controller::setModelsDir(const string& dir) {
+  //_current_dirs->setValue("models/dir", dir);
+}
+
+string		Controller::getModelsDir() const {
+  string dir = ".";
+  //_current_dirs->getValue("models/dir", dir);
+  return dir;
+}
+
+void		Controller::setModulesDir(const string& dir) {
+  //_current_dirs->setValue("modules/dir", dir);
+}
+
+string		Controller::getModulesDir() const {
+  string dir = ".";
+  //_current_dirs->getValue("modules/dir", dir);
+  return dir;
+}
+
+void		Controller::setPapersDir(const string& dir) {
+  //_current_dirs->setValue("papers/dir", dir);
+}
+
+string		Controller::getPapersDir() const {
+  string dir = Config::Path::getInstance()->getPapersDir();
+  //_current_dirs->getValue("papers/dir", dir);
+  return dir;
+}
+
+void		Controller::setHelpIndex(const string& index) {
+  _help_index = index;
+}
+
+string		Controller::getHelpIndex() const {
+  return _help_index;
+}
+
+void		Controller::setBrowserCmd(const string& cmd) {
+  _browser_cmd = cmd;
+}
+
+string		Controller::getBrowserCmd() const {
+  return _browser_cmd;
+}
+
+void		Controller::resetInterpreter() {
+  if (_inter)
+    _inter->reset();
+}
+
+
+void Controller::displayDensityCurves(int x, int y){
+  SteerableViewMap * svm = _Canvas->getSteerableViewMap();
+  if(!svm)
+    return;
+
+  unsigned i,j;
+  typedef vector<Vec3r> densityCurve;
+  vector<densityCurve> curves(svm->getNumberOfOrientations()+1);
+  vector<densityCurve> curvesDirection(svm->getNumberOfPyramidLevels());
+
+  // collect the curves values
+  unsigned nbCurves = svm->getNumberOfOrientations()+1;
+  unsigned nbPoints = svm->getNumberOfPyramidLevels();
+  if(!nbPoints)
+    return;
+
+  // build the density/nbLevels curves for each orientation
+  for(i=0;i<nbCurves; ++i){
+    for(j=0; j<nbPoints; ++j){
+      curves[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(i, j, x, y), 0));
+    }
+  }
+  // build the density/nbOrientations curves for each level
+  for(i=0;i<nbPoints; ++i){
+    for(j=0; j<nbCurves; ++j){
+      curvesDirection[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(j, i, x, y), 0));
+    }
+  }
+
+  // display the curves
+  // for(i=0; i<nbCurves; ++i)
+  //     _pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0,0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
+  //   for(i=1; i<=8; ++i)
+  //     _pDensityCurvesWindow->setLevelCurve(i, Vec2d(0,0), Vec2d(nbCurves, 1), curvesDirection[i], "orientation", "density");
+  //   _pDensityCurvesWindow->show();
+}
+
+void Controller::init_options(){
+// 	from AppOptionsWindow.cpp
+// 	Default init options
+
+	Config::Path * cpath = Config::Path::getInstance();
+	
+	// Directories
+	ViewMapIO::Options::setModelsPath( StringUtils::toAscii( cpath->getModelsPath() ) ); 
+	PythonInterpreter::Options::setPythonPath( StringUtils::toAscii( cpath->getPythonPath() ) );
+	TextureManager::Options::setPatternsPath( StringUtils::toAscii( cpath->getPatternsPath() ) );
+	TextureManager::Options::setBrushesPath( StringUtils::toAscii( cpath->getModelsPath() ) );
+
+	// ViewMap Format
+	ViewMapIO::Options::rmFlags(ViewMapIO::Options::FLOAT_VECTORS);
+	ViewMapIO::Options::rmFlags(ViewMapIO::Options::NO_OCCLUDERS);
+	setComputeSteerableViewMapFlag( false );
+
+	// Visibility
+	setQuantitativeInvisibility(true);
+
+	 // Papers Textures
+	vector<string> sl;
+	sl.push_back( StringUtils::toAscii( cpath->getPapersDir() + Config::DEFAULT_PAPER_TEXTURE ) );
+	TextureManager::Options::setPaperTextures( sl );
+
+	// Drawing Buffers
+	setFrontBufferFlag(false);
+	setBackBufferFlag(true);
+
+	// Ridges and Valleys
+	setComputeRidgesAndValleysFlag( false );
+	
+	// Suggestive Contours
+	setComputeSuggestiveContoursFlag( false );
+	setSphereRadius(1);
+	setSuggestiveContourKrDerivativeEpsilon(0);
+
+	// soc: initialize canvas
+	_Canvas->init();
+}
diff --git a/source/blender/freestyle/intern/app_blender/Controller.h b/source/blender/freestyle/intern/app_blender/Controller.h
new file mode 100755
index 00000000000..032e21a1ce5
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/Controller.h
@@ -0,0 +1,220 @@
+//
+//  Filename         : Controller.h
+//  Author           : Stephane Grabli
+//  Purpose          : The spinal tap of the system
+//  Date of creation : 01/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CONTROLLER_H
+# define CONTROLLER_H
+
+# include <string>
+//# include "ConfigIO.h"
+# include "../geometry/FastGrid.h"
+# include "../geometry/HashGrid.h"
+# include "../view_map/ViewMapBuilder.h"
+# include "../system/TimeUtils.h"
+# include "../system/ProgressBar.h"
+# include "../system/Precision.h"
+# include "../system/Interpreter.h"
+# include "../view_map/FEdgeXDetector.h"
+
+class AppGLWidget;
+class NodeGroup;
+class WShape;
+class SShape;
+class ViewMap;
+class ViewEdge;
+class AppCanvas;
+class InteractiveShader;
+class Shader;
+
+class Controller
+{
+public:
+  Controller() ;
+  ~Controller() ;
+  
+  void setView(AppGLWidget *iView);
+
+  //soc
+	void init_options();
+
+  int  Load3DSFile(const char *iFileName);
+  void CloseFile();
+  void LoadViewMapFile(const char *iFileName, bool only_camera = false);
+  void SaveViewMapFile(const char *iFileName);
+  void ComputeViewMap();
+  void ComputeSteerableViewMap();
+  void saveSteerableViewMapImages();
+  void toggleEdgeTesselationNature(Nature::EdgeNature iNature);
+  void DrawStrokes();
+  void SwapStyleModules(unsigned i1, unsigned i2);
+  void InsertStyleModule(unsigned index, const char *iFileName);
+  void AddStyleModule(const char *iFileName);
+  void RemoveStyleModule(unsigned index);
+  void ReloadStyleModule(unsigned index, const char * iFileName);
+  void Clear();
+  void toggleLayer(unsigned index, bool iDisplay);
+  void setModified(unsigned index, bool iMod);
+  void resetModified(bool iMod=false);
+  void updateCausalStyleModules(unsigned index);
+  void saveSnapshot(bool b = false);
+  void displayDensityCurves(int x, int y);
+ 
+  
+  ViewEdge * SelectViewEdge(real x, real y);
+  FEdge * SelectFEdge(real x, real y);
+  NodeGroup* BuildRep(vector<ViewEdge*>::iterator vedges_begin, 
+		      vector<ViewEdge*>::iterator vedges_end) ;
+  
+  NodeGroup* debugNode() {return _DebugNode;}
+  AppGLWidget * view() {return _pView;}
+  NodeGroup* debugScene() {return _DebugNode;}
+  Grid& grid() {return _Grid;}
+  
+  void toggleVisibilityAlgo();
+
+  void setQuantitativeInvisibility(bool iBool); // if true, we compute quantitativeInvisibility
+  bool getQuantitativeInvisibility() const;
+
+  void setFrontBufferFlag(bool b);
+  bool getFrontBufferFlag() const;
+  void setBackBufferFlag(bool b);
+  bool getBackBufferFlag() const;
+
+  void setComputeRidgesAndValleysFlag(bool b);
+  bool getComputeRidgesAndValleysFlag() const ;
+  void setComputeSuggestiveContoursFlag(bool b);
+  bool getComputeSuggestiveContoursFlag() const ;
+
+  void setComputeSteerableViewMapFlag(bool iBool);
+  bool getComputeSteerableViewMapFlag() const;
+  void setSphereRadius(real s){_sphereRadius=s;}
+  real getSphereRadius() const {return _sphereRadius;}
+  void setSuggestiveContourKrDerivativeEpsilon(real dkr){_suggestiveContourKrDerivativeEpsilon=dkr;}
+  real getSuggestiveContourKrDerivativeEpsilon() const {return _suggestiveContourKrDerivativeEpsilon;}
+
+  void		setModelsDir(const string& dir);
+  string	getModelsDir() const;
+  void		setModulesDir(const string& dir);
+  string	getModulesDir() const;
+  void		setPapersDir(const string& dir);
+  string	getPapersDir() const;
+  void		setHelpIndex(const string& dir);
+  string	getHelpIndex() const;
+  void		setBrowserCmd(const string& cmd);
+  string	getBrowserCmd() const;
+
+  void resetInterpreter();
+
+private:
+
+  // Main Window:
+  //AppMainWindow *_pMainWindow;
+
+  // List of models currently loaded
+  vector<string> _ListOfModels;
+
+  // Current directories
+  //ConfigIO* _current_dirs;
+
+  //View
+  // 3D
+  AppGLWidget *_pView;
+  
+  // 2D
+  //Viewer2DWindow *_pView2DWindow;
+  //Viewer2D *_pView2D;
+  
+  //Model
+  // Drawing Structure
+  NodeGroup *_RootNode;
+
+  // Winged-Edge structure
+  WingedEdge* _winged_edge;
+  
+  ViewMap * _ViewMap;
+
+  // Silhouette structure:
+  //std::vector<SShape*> _SShapes;
+  //NodeGroup *_SRoot;
+  
+  // Silhouette
+  NodeGroup *_SilhouetteNode;
+  NodeGroup *_ProjectedSilhouette;
+  NodeGroup *_VisibleProjectedSilhouette;
+  
+  // more Debug info
+  NodeGroup *_DebugNode;
+
+  // debug
+  //  NodeUser<ViewMap> *_ViewMapNode; // FIXME
+
+  // Chronometer:
+  Chronometer _Chrono;
+
+	// Progress Bar
+  ProgressBar *_ProgressBar;
+
+  // edges tesselation nature
+  int _edgeTesselationNature;
+
+  FastGrid _Grid;
+  //HashGrid _Grid;
+  
+  unsigned int _SceneNumFaces;
+  real _minEdgeSize;
+  real _EPSILON;
+  real _bboxDiag;
+
+  AppCanvas *_Canvas;
+
+  //AppStyleWindow *_pStyleWindow;
+  //AppOptionsWindow *_pOptionsWindow;
+  //AppDensityCurvesWindow *_pDensityCurvesWindow;
+
+  ViewMapBuilder::visibility_algo	_VisibilityAlgo;
+  
+  // Script Interpreter
+  Interpreter* _inter;
+
+  string	_help_index;
+  string	_browser_cmd;
+
+  bool _EnableQI;
+  bool _ComputeRidges;
+  bool _ComputeSuggestive;
+  real _sphereRadius;
+  real _suggestiveContourKrDerivativeEpsilon;
+
+  bool _ComputeSteerableViewMap;
+
+  FEdgeXDetector edgeDetector;
+};
+
+extern Controller	*g_pController;
+
+#endif // CONTROLLER_H
diff --git a/source/blender/freestyle/intern/app_blender/api.cpp b/source/blender/freestyle/intern/app_blender/api.cpp
new file mode 100644
index 00000000000..27b8d578e2f
--- /dev/null
+++ b/source/blender/freestyle/intern/app_blender/api.cpp
@@ -0,0 +1,197 @@
+#include "AppGLWidget.h"
+#include "Controller.h"
+#include "AppConfig.h"
+
+#include <iostream>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "DNA_camera_types.h"
+
+#include "render_types.h"
+#include "renderpipeline.h"
+
+#include "BLI_blenlib.h"
+#include "BPY_extern.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+using namespace std;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	static Config::Path *pathconfig = NULL;
+	static Controller *controller = NULL;
+	static AppGLWidget *view = NULL;
+
+	
+	void FRS_initialize(){
+		
+		if( pathconfig == NULL )
+			pathconfig = new Config::Path;
+		
+		if( controller == NULL )
+			controller = new Controller;
+		
+		if( view == NULL )
+			view = new AppGLWidget;
+		
+		controller->setView(view);
+	}
+
+
+	void FRS_init_view(Render* re){
+		view->setWidth( re->winx );
+		view->setHeight( re->winy );
+		view->_camera->setScreenWidthAndHeight( re->winx, re->winy);
+	}
+
+	void FRS_init_camera(Render* re){
+		Object* maincam_obj = re->scene->camera;
+		Camera *cam = (Camera*) maincam_obj->data;
+
+		if(cam->type == CAM_PERSP){
+			view->_camera->setType(AppGLWidget_Camera::PERSPECTIVE);
+			view->_camera->setHorizontalFieldOfView( M_PI / 180.0f * cam->angle );
+		}
+		// else if (cam->type == CAM_ORTHO){
+		// 	view->_camera->setType(AppGLWidget_Camera::ORTHOGRAPHIC);
+		// 	// view->_camera->setFocusDistance does not seem to work
+		// 	// integrate cam->ortho_scale parameter
+		// }
+		
+		Vec camPosition(maincam_obj->obmat[3][0], maincam_obj->obmat[3][1], maincam_obj->obmat[3][2]);
+		Vec camUp( re->viewmat[0][1], re->viewmat[1][1], re->viewmat[2][1]);
+		Vec camDirection( -re->viewmat[0][2], -re->viewmat[1][2], -re->viewmat[2][2]);
+		view->_camera->setPosition(camPosition);
+		view->_camera->setUpVector(camUp);	
+		view->_camera->setViewDirection(camDirection);
+	}
+	
+	void FRS_scene_3ds_export(Render* re) {
+		// export scene to 3ds format
+		string script_3ds_export = 	pathconfig->getProjectDir() + 
+									Config::DIR_SEP + "python" + 
+									Config::DIR_SEP + "3ds_export.py";
+		BPY_run_python_script( const_cast<char *>(script_3ds_export.c_str()) );
+		
+		// load 3ds scene
+		char btempdir[255];
+		BLI_where_is_temp(btempdir,1);
+		string exported_3ds_file =  btempdir;
+		exported_3ds_file += Config::DIR_SEP + "tmp_scene_freestyle.3ds";
+		if( BLI_exists( const_cast<char *>(exported_3ds_file.c_str()) ) ) {
+			controller->Load3DSFile( exported_3ds_file.c_str() );
+		}
+		else {
+			cout << "Cannot find" << exported_3ds_file << endl;
+			return;
+		}
+	}
+	
+	void FRS_prepare(Render* re) {
+		FRS_initialize();
+		
+		FRS_init_view(re);
+		FRS_init_camera(re);
+		
+		FRS_scene_3ds_export(re);
+	}
+
+	void FRS_render(Render* re, int render_in_layer) {
+		
+		if(render_in_layer) {
+			view->workingBuffer = GL_COLOR_ATTACHMENT1_EXT;
+		} else {
+			view->workingBuffer = GL_BACK;
+		}
+		
+		// add style module
+		string style_module = pathconfig->getProjectDir() + 
+								Config::DIR_SEP + "style_modules" + 
+								Config::DIR_SEP + "contour.py";
+		controller->InsertStyleModule( 0, const_cast<char *>(style_module.c_str()) 	 );
+		controller->toggleLayer(0, true);
+		
+		// compute view map
+		controller->ComputeViewMap();
+		
+		// build strokes
+		controller->DrawStrokes(); 
+		
+		// render final result
+		view->draw(); 
+	}
+
+	void FRS_execute(Render* re, int render_in_layer) {
+		
+		if(render_in_layer) {
+
+		// 	GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+		// 	switch(status){
+		// 		case GL_FRAMEBUFFER_COMPLETE_EXT:
+		// 		cout << "CORRECT: GL_FRAMEBUFFER_COMPLETE" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" << endl;
+		// 		break;
+		// 		case GL_FRAMEBUFFER_UNSUPPORTED_EXT: 
+		// 		cout << "ERROR: GL_FRAMEBUFFER_UNSUPPORTED" << endl;
+		// 		break;
+		// }
+		
+			RenderLayer *rl;
+		
+			for(rl = (RenderLayer *)re->result->layers.first; rl; rl= rl->next)
+				if(rl->layflag & SCE_LAY_FRS)
+					break;
+			
+			int p;
+			for(int j = 0; j < re->winy; j++) {
+				for(int i = 0; i < re->winx; i++){
+					p = 4*(j*re->winx + i);
+					rl->rectf[p]      *= 0.6;
+					rl->rectf[p + 1]  = 0.6 * rl->rectf[p + 1];
+					rl->rectf[p + 2] *= 0.6;
+					rl->rectf[p + 3]  = 1.0;
+				}
+			}
+			
+		} else {
+			FRS_render(re, render_in_layer);
+			
+			RenderResult rres;
+			RE_GetResultImage(re, &rres);
+			view->readPixels(0, 0, re->winx, re->winy, AppGLWidget::RGBA, rres.rectf );		
+			re->result->renlay = render_get_active_layer(re, re->result);
+			re->display_draw(re->result, NULL);
+		}
+
+		
+		controller->CloseFile();
+	}
+	
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/geometry/BBox.h b/source/blender/freestyle/intern/geometry/BBox.h
new file mode 100755
index 00000000000..9c46d7918e2
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/BBox.h
@@ -0,0 +1,141 @@
+//
+//  Filename         : BBox.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : A class to hold a bounding box
+//  Date of creation : 22/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  BBOX_H
+# define BBOX_H
+
+template <class Point>
+class BBox
+{
+ public:
+
+  inline BBox() {
+    _empty = true;
+  }
+
+  template <class T>
+  inline BBox(const T& min_in, const T& max_in) : _min(min_in), _max(max_in) {
+    _empty = false;
+  }
+
+  template <class T>
+  inline BBox(const BBox<T>& b) : _min(b.getMin()), _max(b.getMax()) {
+    _empty = false;
+  }
+
+  template <class T>
+  inline void extendToContain(const T& p) {
+    if (_empty) {
+      _min = p;
+      _max = p;
+      _empty = false;
+      return;
+    }
+    for (unsigned i = 0; i < Point::dim(); i++) {
+      if (p[i] < _min[i])
+	_min[i] = p[i];
+      else if (p[i] > _max[i])
+	_max[i] = p[i];
+    }
+    _empty = false;
+  }
+
+  inline void clear() {
+    _empty = true;
+  }
+
+  inline bool empty() const {
+    return _empty;
+  }
+
+  inline const Point& getMin() const {
+    return _min;
+  }
+
+  inline const Point& getMax() const {
+    return _max;
+  }
+
+  inline BBox<Point>& operator=(const BBox<Point>& b) {
+    _min = b.getMin();
+    _max = b.getMax();
+    _empty = false;
+    return *this;
+  }
+
+  inline BBox<Point>& operator+=(const BBox<Point>& b) {
+    if (_empty) {
+      _min = b.getMin();
+      _max = b.getMax();
+      _empty = false;
+    }
+    else {
+      for (unsigned i = 0; i < Point::dim(); i++) {
+	if (b.getMin()[i] < _min[i])
+	  _min[i] = b.getMin()[i];
+	if (b.getMax()[i] > _max[i])
+	  _max[i] = b.getMax()[i];
+      }
+    }
+    return *this;
+  }
+
+  inline bool inside(const Point& p){
+    if(empty())
+        return false;
+    for (unsigned i = 0; i < Point::dim(); i++) {
+        if((_min[i]>p[i]) || (_max[i]<p[i]))
+            return false;
+    }
+    return true;
+
+  }
+
+private:
+
+  Point	_min;
+  Point	_max;
+  bool	_empty;
+};
+
+template <class Point>
+BBox<Point>& operator+(const BBox<Point> &b1, const BBox<Point> &b2)
+{
+  Point new_min;
+  Point new_max;
+
+  for (unsigned i = 0; i < Point::dim(); i++) {
+    new_min[i] = b1.getMin()[i] < b2.getMin()[i] ? b1.getMin()[i] : b2.getMin()[i];
+    new_max[i] = b1.getMax()[i] > b2.getMax()[i] ? b1.getMax()[i] : b2.getMax()[i];
+  }
+
+  return BBox<Point>(new_min, new_max);
+}
+
+#endif // BBOX_H
diff --git a/source/blender/freestyle/intern/geometry/Bezier.cpp b/source/blender/freestyle/intern/geometry/Bezier.cpp
new file mode 100755
index 00000000000..8f9771f29d3
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Bezier.cpp
@@ -0,0 +1,118 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Bezier.h"
+#include "FitCurve.h"
+
+using namespace std;
+
+BezierCurveSegment::BezierCurveSegment()
+{
+}
+
+BezierCurveSegment::~BezierCurveSegment()
+{
+}
+
+void BezierCurveSegment::AddControlPoint(const Vec2d& iPoint)
+{
+  _ControlPolygon.push_back(iPoint);
+  if(_ControlPolygon.size() == 4)
+    Build();
+}
+
+void BezierCurveSegment::Build()
+{
+  if(_ControlPolygon.size() != 4)
+    return;
+
+  // Compute the rightmost part of the matrix:
+  vector<Vec2d>::const_iterator p0,p1,p2,p3;
+  p0 = _ControlPolygon.begin();
+  p1 = p0;++p1;
+  p2 = p1;++p2;
+  p3 = p2;++p3;
+  float x[4], y[4];
+  
+  x[0] = -p0->x()+3*p1->x()-3*p2->x()+p3->x();
+  x[1] = 3*p0->x()-6*p1->x()+3*p2->x();
+  x[2] = -3*p0->x()+3*p1->x();
+  x[3] = p0->x();
+
+  y[0] = -p0->y()+3*p1->y()-3*p2->y()+p3->y();
+  y[1] = 3*p0->y()-6*p1->y()+3*p2->y();
+  y[2] = -3*p0->y()+3*p1->y();
+  y[3] = p0->y();
+
+  int nvertices = 12;
+  float increment = 1.0/(float)nvertices;
+  float t = 0.f;
+  for(int i=0; i<=nvertices; ++i)
+  {
+    _Vertices.push_back(Vec2d((x[3] + t*(x[2] + t*(x[1] + t*x[0]))), 
+                              (y[3] + t*(y[2] + t*(y[1] + t*y[0])))));
+    t+=increment;
+  }
+}
+
+BezierCurve::BezierCurve()
+{
+  _currentSegment = new BezierCurveSegment;
+}
+
+BezierCurve::BezierCurve(vector<Vec2d>& iPoints, double error)
+{
+  FitCurveWrapper fitcurve;
+  _currentSegment = new BezierCurveSegment;
+  vector<Vec2d> curve;
+
+  fitcurve.FitCurve(iPoints, curve, error);
+  int i=0;
+  vector<Vec2d>::iterator v,vend;
+  for(v=curve.begin(),vend=curve.end();
+  v!=vend;
+  ++v)
+  {
+    if((i == 0) || (i%4 != 0))
+      AddControlPoint(*v);
+    ++i;
+  }
+}
+
+BezierCurve::~BezierCurve()
+{
+  if(_currentSegment)
+    delete _currentSegment;
+}
+
+void BezierCurve::AddControlPoint(const Vec2d& iPoint)
+{
+  _ControlPolygon.push_back(iPoint);
+  _currentSegment->AddControlPoint(iPoint);
+  if(_currentSegment->size() == 4)
+  {
+    _Segments.push_back(_currentSegment);
+    _currentSegment = new BezierCurveSegment;
+    _currentSegment->AddControlPoint(iPoint);
+  }
+}
+
+
diff --git a/source/blender/freestyle/intern/geometry/Bezier.h b/source/blender/freestyle/intern/geometry/Bezier.h
new file mode 100755
index 00000000000..acae71bbb2c
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Bezier.h
@@ -0,0 +1,73 @@
+//
+//  Filename         : Bezier.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a Bezier curve of order 4.
+//  Date of creation : 04/06/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  BEZIER_H
+# define BEZIER_H
+
+#include <vector>
+#include "../system/FreestyleConfig.h"
+#include "Geom.h"
+
+using namespace Geometry;
+
+class LIB_GEOMETRY_EXPORT BezierCurveSegment 
+{
+private:
+  std::vector<Vec2d> _ControlPolygon;
+  std::vector<Vec2d> _Vertices;
+
+public:
+  BezierCurveSegment();
+  virtual ~BezierCurveSegment();
+
+  void AddControlPoint(const Vec2d& iPoint);
+  void Build();
+  inline int size() const {return _ControlPolygon.size();}
+  inline std::vector<Vec2d>& vertices() {return _Vertices;}
+};
+
+
+class LIB_GEOMETRY_EXPORT BezierCurve 
+{
+private:
+  std::vector<Vec2d> _ControlPolygon;
+  std::vector<BezierCurveSegment*> _Segments;
+  BezierCurveSegment *_currentSegment;
+
+public:
+  BezierCurve();
+  BezierCurve(std::vector<Vec2d>& iPoints, double error=4.0);
+  virtual ~BezierCurve();
+
+  void AddControlPoint(const Vec2d& iPoint);
+  std::vector<Vec2d>& controlPolygon() {return _ControlPolygon;}
+  std::vector<BezierCurveSegment*>& segments() {return _Segments;}
+};
+
+#endif // BEZIER_H
diff --git a/source/blender/freestyle/intern/geometry/FastGrid.cpp b/source/blender/freestyle/intern/geometry/FastGrid.cpp
new file mode 100755
index 00000000000..b090a3df67f
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/FastGrid.cpp
@@ -0,0 +1,62 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "FastGrid.h"
+
+void FastGrid::clear() {
+  if(!_cells)
+    return;
+
+  for(unsigned i = 0; i < _cells_size; i++)
+    if (_cells[i])
+      delete _cells[i];
+  delete[] _cells;
+  _cells = NULL;
+  _cells_size = 0;
+
+  Grid::clear();
+}
+
+void FastGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb) {
+  Grid::configure(orig, size, nb);
+  _cells_size = _cells_nb[0] * _cells_nb[1] * _cells_nb[2];
+  _cells = new Cell*[_cells_size];
+  memset(_cells, 0, _cells_size * sizeof(*_cells));
+}
+
+Cell* FastGrid::getCell(const Vec3u& p) {
+    //cout << _cells<< " "<< p << " " <<_cells_nb[0]<<"-"<< _cells_nb[1]<<"-"<< _cells_nb[2]<< " "<<_cells_size<< endl;
+    assert(_cells||("_cells is a null pointer"));
+    assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0])<_cells_size);
+    assert(p[0]<_cells_nb[0]);
+    assert(p[1]<_cells_nb[1]);
+    assert(p[2]<_cells_nb[2]);
+    return _cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]];
+}
+
+void FastGrid::fillCell(const Vec3u& p, Cell& cell) {
+    assert(_cells||("_cells is a null pointer"));
+    assert((_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0])<_cells_size);
+    assert(p[0]<_cells_nb[0]);
+    assert(p[1]<_cells_nb[1]);
+    assert(p[2]<_cells_nb[2]);
+    _cells[_cells_nb[0] * (p[2] * _cells_nb[1] + p[1]) + p[0]] = &cell;
+}
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/geometry/FastGrid.h b/source/blender/freestyle/intern/geometry/FastGrid.h
new file mode 100755
index 00000000000..e620ff24385
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/FastGrid.h
@@ -0,0 +1,85 @@
+//
+//  Filename         : FastGrid.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a cell grid surrounding the
+//                     bounding box of the scene
+//  Date of creation : 30/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  FASTGRID_H
+# define FASTGRID_H
+
+# include "Grid.h"
+# include <cassert>
+/*! Class to define a regular grid used for ray
+ *  casting computations 
+ *  We don't use a hashtable here. The grid is 
+ *  explicitly stored for faster computations.
+ *  However, this might result in significant
+ *  increase in memory usage (compared to the regular grid)
+ */
+
+class LIB_GEOMETRY_EXPORT FastGrid : public Grid
+{
+ public:
+
+  FastGrid() : Grid() {
+    _cells = NULL;
+    _cells_size = 0;
+  }
+  
+  virtual ~FastGrid() {
+    clear();
+  }
+
+  /*! clears the grid
+   *  Deletes all the cells, clears the hashtable,
+   *  resets size, size of cell, number of cells.
+   */
+  virtual void clear();
+  
+  /*! Sets the different parameters of the grid
+   *    orig
+   *      The grid origin
+   *    size
+   *      The grid's dimensions
+   *    nb
+   *      The number of cells of the grid
+   */
+  virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
+  
+  /*! returns the cell whose coordinates are pased as argument */
+  Cell* getCell(const Vec3u& p) ;
+ 
+  /*! Fills the case p with the cell iCell */
+  virtual void fillCell(const Vec3u& p, Cell& cell);
+
+protected:
+
+  Cell**	_cells;
+  unsigned	_cells_size;
+};
+
+#endif // FASTGRID_H
diff --git a/source/blender/freestyle/intern/geometry/FitCurve.cpp b/source/blender/freestyle/intern/geometry/FitCurve.cpp
new file mode 100755
index 00000000000..ade40b050ca
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/FitCurve.cpp
@@ -0,0 +1,602 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include <math.h>
+#include "FitCurve.h"
+
+using namespace std;
+
+typedef Vector2 *BezierCurve;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* Forward declarations */
+static double *Reparameterize(Vector2 *d, int first, int last, double *u, BezierCurve bezCurve);
+static double NewtonRaphsonRootFind(BezierCurve Q, Vector2 P, double u);
+static Vector2 BezierII(int degree, Vector2 *V, double t);
+static double B0(double u);
+static double B1(double u);
+static double B2(double u);
+static double B3(double u);
+static Vector2 ComputeLeftTangent(Vector2 *d, int end);
+static Vector2 ComputeLeftTangent(Vector2 *d, int end);
+static Vector2 ComputeLeftTangent(Vector2 *d, int end);
+static double ComputeMaxError(Vector2 *d, int first, int last, BezierCurve bezCurve, double *u, int *splitPoint);
+static double *ChordLengthParameterize(Vector2 *d, int first, int last);
+static BezierCurve  GenerateBezier(Vector2 *d, int first, int last, double *uPrime, Vector2 tHat1, Vector2 tHat2);
+static Vector2 V2AddII(Vector2 a, Vector2 b);
+static Vector2 V2ScaleIII(Vector2 v, double s);
+static Vector2 V2SubII(Vector2 a, Vector2 b);
+
+
+#define MAXPOINTS	1000		/* The most points you can have */
+
+/* returns squared length of input vector */	
+double V2SquaredLength(Vector2 *a) 
+{	return(((*a)[0] * (*a)[0])+((*a)[1] * (*a)[1]));
+}
+	
+/* returns length of input vector */
+double V2Length(Vector2 *a) 
+{
+	return(sqrt(V2SquaredLength(a)));
+}
+
+Vector2 *V2Scale(Vector2 *v, double newlen) 
+{
+  double len = V2Length(v);
+	if (len != 0.0) { (*v)[0] *= newlen/len;   (*v)[1] *= newlen/len; }
+	return(v);
+}
+
+/* return the dot product of vectors a and b */
+double V2Dot(Vector2 *a, Vector2 *b) 
+{
+	return(((*a)[0]*(*b)[0])+((*a)[1]*(*b)[1]));
+}
+
+/* return the distance between two points */
+double V2DistanceBetween2Points(Vector2 *a, Vector2 *b)
+{
+double dx = (*a)[0] - (*b)[0];
+double dy = (*a)[1] - (*b)[1];
+	return(sqrt((dx*dx)+(dy*dy)));
+}
+
+/* return vector sum c = a+b */
+Vector2 *V2Add(Vector2 *a, Vector2 *b, Vector2 *c)
+{
+	(*c)[0] = (*a)[0]+(*b)[0];  (*c)[1] = (*a)[1]+(*b)[1];
+	return(c);
+} 
+
+/* normalizes the input vector and returns it */
+Vector2 *V2Normalize(Vector2 *v) 
+{
+double len = V2Length(v);
+	if (len != 0.0) { (*v)[0] /= len;  (*v)[1] /= len; }
+	return(v);
+}
+
+/* negates the input vector and returns it */
+Vector2 *V2Negate(Vector2 *v) 
+{
+	(*v)[0] = -(*v)[0];  (*v)[1] = -(*v)[1];
+	return(v);
+}
+
+ 
+/*
+ *  GenerateBezier :
+ *  Use least-squares method to find Bezier control points for region.
+ *
+ */
+static BezierCurve  GenerateBezier(Vector2 *d, int first, int last, double *uPrime, Vector2 tHat1, Vector2 tHat2)
+//    Vector2	*d;			/*  Array of digitized points	*/
+//    int		first, last;		/*  Indices defining region	*/
+//    double	*uPrime;		/*  Parameter values for region */
+//    Vector2	tHat1, tHat2;	/*  Unit tangents at endpoints	*/
+{
+    int 	i;
+    Vector2 	A[MAXPOINTS][2];	/* Precomputed rhs for eqn	*/
+    int 	nPts;			/* Number of pts in sub-curve */
+    double 	C[2][2];			/* Matrix C		*/
+    double 	X[2];			/* Matrix X			*/
+    double 	det_C0_C1,		/* Determinants of matrices	*/
+    	   	det_C0_X,
+	   		det_X_C1;
+    double 	alpha_l,		/* Alpha values, left and right	*/
+    	   	alpha_r;
+    Vector2 	tmp;			/* Utility variable		*/
+    BezierCurve	bezCurve;	/* RETURN bezier curve ctl pts	*/
+
+    bezCurve = (Vector2 *)malloc(4 * sizeof(Vector2));
+    nPts = last - first + 1;
+
+ 
+    /* Compute the A's	*/
+    for (i = 0; i < nPts; i++) {
+		Vector2		v1, v2;
+		v1 = tHat1;
+		v2 = tHat2;
+		V2Scale(&v1, B1(uPrime[i]));
+		V2Scale(&v2, B2(uPrime[i]));
+		A[i][0] = v1;
+		A[i][1] = v2;
+    }
+
+    /* Create the C and X matrices	*/
+    C[0][0] = 0.0;
+    C[0][1] = 0.0;
+    C[1][0] = 0.0;
+    C[1][1] = 0.0;
+    X[0]    = 0.0;
+    X[1]    = 0.0;
+
+    for (i = 0; i < nPts; i++) {
+        C[0][0] += V2Dot(&A[i][0], &A[i][0]);
+		C[0][1] += V2Dot(&A[i][0], &A[i][1]);
+/*					C[1][0] += V2Dot(&A[i][0], &A[i][1]);*/	
+		C[1][0] = C[0][1];
+		C[1][1] += V2Dot(&A[i][1], &A[i][1]);
+
+		tmp = V2SubII(d[first + i],
+	        V2AddII(
+	          V2ScaleIII(d[first], B0(uPrime[i])),
+		    	V2AddII(
+		      		V2ScaleIII(d[first], B1(uPrime[i])),
+		        			V2AddII(
+	                  		V2ScaleIII(d[last], B2(uPrime[i])),
+	                    		V2ScaleIII(d[last], B3(uPrime[i]))))));
+	
+
+	X[0] += V2Dot(&((A[i])[0]), &tmp);
+	X[1] += V2Dot(&((A[i])[1]), &tmp);
+    }
+
+    /* Compute the determinants of C and X	*/
+    det_C0_C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];
+    det_C0_X  = C[0][0] * X[1]    - C[0][1] * X[0];
+    det_X_C1  = X[0]    * C[1][1] - X[1]    * C[0][1];
+
+    /* Finally, derive alpha values	*/
+    if (det_C0_C1 == 0.0) {
+		det_C0_C1 = (C[0][0] * C[1][1]) * 10e-12;
+    }
+    alpha_l = det_X_C1 / det_C0_C1;
+    alpha_r = det_C0_X / det_C0_C1;
+
+
+    /*  If alpha negative, use the Wu/Barsky heuristic (see text) */
+	/* (if alpha is 0, you get coincident control points that lead to
+	 * divide by zero in any subsequent NewtonRaphsonRootFind() call. */
+    if (alpha_l < 1.0e-6 || alpha_r < 1.0e-6) {
+		double	dist = V2DistanceBetween2Points(&d[last], &d[first]) /
+					3.0;
+
+		bezCurve[0] = d[first];
+		bezCurve[3] = d[last];
+		V2Add(&(bezCurve[0]), V2Scale(&(tHat1), dist), &(bezCurve[1]));
+		V2Add(&(bezCurve[3]), V2Scale(&(tHat2), dist), &(bezCurve[2]));
+		return (bezCurve);
+    }
+
+    /*  First and last control points of the Bezier curve are */
+    /*  positioned exactly at the first and last data points */
+    /*  Control points 1 and 2 are positioned an alpha distance out */
+    /*  on the tangent vectors, left and right, respectively */
+    bezCurve[0] = d[first];
+    bezCurve[3] = d[last];
+    V2Add(&bezCurve[0], V2Scale(&tHat1, alpha_l), &bezCurve[1]);
+    V2Add(&bezCurve[3], V2Scale(&tHat2, alpha_r), &bezCurve[2]);
+    return (bezCurve);
+}
+
+
+/*
+ *  Reparameterize:
+ *	Given set of points and their parameterization, try to find
+ *   a better parameterization.
+ *
+ */
+static double *Reparameterize(Vector2 *d, int first, int last, double *u, BezierCurve bezCurve)
+//    Vector2	*d;			/*  Array of digitized points	*/
+//    int		first, last;		/*  Indices defining region	*/
+//    double	*u;			/*  Current parameter values	*/
+//    BezierCurve	bezCurve;	/*  Current fitted curve	*/
+{
+    int 	nPts = last-first+1;	
+    int 	i;
+    double	*uPrime;		/*  New parameter values	*/
+
+    uPrime = (double *)malloc(nPts * sizeof(double));
+    for (i = first; i <= last; i++) {
+		uPrime[i-first] = NewtonRaphsonRootFind(bezCurve, d[i], u[i-
+					first]);
+    }
+    return (uPrime);
+}
+
+
+
+/*
+ *  NewtonRaphsonRootFind :
+ *	Use Newton-Raphson iteration to find better root.
+ */
+static double NewtonRaphsonRootFind(BezierCurve Q, Vector2 P, double u)
+//    BezierCurve	Q;			/*  Current fitted curve	*/
+//    Vector2 		P;		/*  Digitized point		*/
+//    double 		u;		/*  Parameter value for "P"	*/
+{
+    double 		numerator, denominator;
+    Vector2 		Q1[3], Q2[2];	/*  Q' and Q''			*/
+    Vector2		Q_u, Q1_u, Q2_u; /*u evaluated at Q, Q', & Q''	*/
+    double 		uPrime;		/*  Improved u			*/
+    int 		i;
+    
+    /* Compute Q(u)	*/
+    Q_u = BezierII(3, Q, u);
+    
+    /* Generate control vertices for Q'	*/
+    for (i = 0; i <= 2; i++) {
+		Q1[i][0] = (Q[i+1][0] - Q[i][0]) * 3.0;
+		Q1[i][1] = (Q[i+1][1] - Q[i][1]) * 3.0;
+    }
+    
+    /* Generate control vertices for Q'' */
+    for (i = 0; i <= 1; i++) {
+		Q2[i][0] = (Q1[i+1][0] - Q1[i][0]) * 2.0;
+		Q2[i][1] = (Q1[i+1][1] - Q1[i][1]) * 2.0;
+    }
+    
+    /* Compute Q'(u) and Q''(u)	*/
+    Q1_u = BezierII(2, Q1, u);
+    Q2_u = BezierII(1, Q2, u);
+    
+    /* Compute f(u)/f'(u) */
+    numerator = (Q_u[0] - P[0]) * (Q1_u[0]) + (Q_u[1] - P[1]) * (Q1_u[1]);
+    denominator = (Q1_u[0]) * (Q1_u[0]) + (Q1_u[1]) * (Q1_u[1]) +
+		      	  (Q_u[0] - P[0]) * (Q2_u[0]) + (Q_u[1] - P[1]) * (Q2_u[1]);
+    
+    /* u = u - f(u)/f'(u) */
+    if(denominator == 0) // FIXME
+      return u;
+    uPrime = u - (numerator/denominator);
+    return (uPrime);
+}
+
+	
+		       
+/*
+ *  Bezier :
+ *  	Evaluate a Bezier curve at a particular parameter value
+ * 
+ */
+static Vector2 BezierII(int degree, Vector2 *V, double t)
+//    int		degree;		/* The degree of the bezier curve	*/
+//    Vector2 	*V;		/* Array of control points		*/
+//    double 	t;		/* Parametric value to find point for	*/
+{
+    int 	i, j;		
+    Vector2 	Q;	        /* Point on curve at parameter t	*/
+    Vector2 	*Vtemp;		/* Local copy of control points		*/
+
+    /* Copy array	*/
+    Vtemp = (Vector2 *)malloc((unsigned)((degree+1) 
+				* sizeof (Vector2)));
+    for (i = 0; i <= degree; i++) {
+		Vtemp[i] = V[i];
+    }
+
+    /* Triangle computation	*/
+    for (i = 1; i <= degree; i++) {	
+		for (j = 0; j <= degree-i; j++) {
+	    	Vtemp[j][0] = (1.0 - t) * Vtemp[j][0] + t * Vtemp[j+1][0];
+	    	Vtemp[j][1] = (1.0 - t) * Vtemp[j][1] + t * Vtemp[j+1][1];
+		}
+    }
+
+    Q = Vtemp[0];
+    free((void *)Vtemp);
+    return Q;
+}
+
+
+/*
+ *  B0, B1, B2, B3 :
+ *	Bezier multipliers
+ */
+static double B0(double u)
+{
+    double tmp = 1.0 - u;
+    return (tmp * tmp * tmp);
+}
+
+
+static double B1(double u)
+{
+    double tmp = 1.0 - u;
+    return (3 * u * (tmp * tmp));
+}
+
+static double B2(double u)
+{
+    double tmp = 1.0 - u;
+    return (3 * u * u * tmp);
+}
+
+static double B3(double u)
+{
+    return (u * u * u);
+}
+
+
+
+/*
+ * ComputeLeftTangent, ComputeRightTangent, ComputeCenterTangent :
+ *Approximate unit tangents at endpoints and "center" of digitized curve
+ */
+static Vector2 ComputeLeftTangent(Vector2 *d, int end)
+//    Vector2	*d;			/*  Digitized points*/
+//    int		end;		/*  Index to "left" end of region */
+{
+    Vector2	tHat1;
+    tHat1 = V2SubII(d[end+1], d[end]);
+    tHat1 = *V2Normalize(&tHat1);
+    return tHat1;
+}
+
+static Vector2 ComputeRightTangent(Vector2 *d, int end)
+//    Vector2	*d;			/*  Digitized points		*/
+//    int		end;		/*  Index to "right" end of region */
+{
+    Vector2	tHat2;
+    tHat2 = V2SubII(d[end-1], d[end]);
+    tHat2 = *V2Normalize(&tHat2);
+    return tHat2;
+}
+
+static Vector2 ComputeCenterTangent(Vector2 *d, int center)
+//    Vector2	*d;			/*  Digitized points			*/
+//    int		center;		/*  Index to point inside region	*/
+{
+    Vector2	V1, V2, tHatCenter;
+
+    V1 = V2SubII(d[center-1], d[center]);
+    V2 = V2SubII(d[center], d[center+1]);
+    tHatCenter[0] = (V1[0] + V2[0])/2.0;
+    tHatCenter[1] = (V1[1] + V2[1])/2.0;
+    tHatCenter = *V2Normalize(&tHatCenter);
+    return tHatCenter;
+}
+
+
+/*
+ *  ChordLengthParameterize :
+ *	Assign parameter values to digitized points 
+ *	using relative distances between points.
+ */
+static double *ChordLengthParameterize(Vector2 *d, int first, int last)
+//    Vector2	*d;			/* Array of digitized points */
+//    int		first, last;		/*  Indices defining region	*/
+{
+    int		i;	
+    double	*u;			/*  Parameterization		*/
+
+    u = (double *)malloc((unsigned)(last-first+1) * sizeof(double));
+
+    u[0] = 0.0;
+    for (i = first+1; i <= last; i++) {
+		u[i-first] = u[i-first-1] +
+	  			V2DistanceBetween2Points(&d[i], &d[i-1]);
+    }
+
+    for (i = first + 1; i <= last; i++) {
+		u[i-first] = u[i-first] / u[last-first];
+    }
+
+    return(u);
+}
+
+
+
+
+/*
+ *  ComputeMaxError :
+ *	Find the maximum squared distance of digitized points
+ *	to fitted curve.
+*/
+static double ComputeMaxError(Vector2 *d, int first, int last, BezierCurve bezCurve, double *u, int *splitPoint)
+//    Vector2	*d;			/*  Array of digitized points	*/
+//    int		first, last;		/*  Indices defining region	*/
+//    BezierCurve	bezCurve;		/*  Fitted Bezier curve		*/
+//    double	*u;			/*  Parameterization of points	*/
+//    int		*splitPoint;		/*  Point of maximum error	*/
+{
+    int		i;
+    double	maxDist;		/*  Maximum error		*/
+    double	dist;		/*  Current error		*/
+    Vector2	P;			/*  Point on curve		*/
+    Vector2	v;			/*  Vector from point to curve	*/
+
+    *splitPoint = (last - first + 1)/2;
+    maxDist = 0.0;
+    for (i = first + 1; i < last; i++) {
+		P = BezierII(3, bezCurve, u[i-first]);
+		v = V2SubII(P, d[i]);
+		dist = V2SquaredLength(&v);
+		if (dist >= maxDist) {
+	    	maxDist = dist;
+	    	*splitPoint = i;
+		}
+    }
+    return (maxDist);
+}
+static Vector2 V2AddII(Vector2 a, Vector2 b)
+{
+    Vector2	c;
+    c[0] = a[0] + b[0];  c[1] = a[1] + b[1];
+    return (c);
+}
+static Vector2 V2ScaleIII(Vector2 v, double s)
+{
+    Vector2 result;
+    result[0] = v[0] * s; result[1] = v[1] * s;
+    return (result);
+}
+
+static Vector2 V2SubII(Vector2 a, Vector2 b)
+{
+    Vector2	c;
+    c[0] = a[0] - b[0]; c[1] = a[1] - b[1];
+    return (c);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+//------------------------- WRAPPER -----------------------------//
+
+FitCurveWrapper::FitCurveWrapper()
+{
+}
+
+FitCurveWrapper::~FitCurveWrapper()
+{
+  _vertices.clear();
+}
+
+void FitCurveWrapper::DrawBezierCurve(int n, Vector2 *curve )
+{
+	for(int i=0; i<n+1; ++i)
+    _vertices.push_back(curve[i]);
+}
+
+void FitCurveWrapper::FitCurve(vector<Vec2d>& data, vector<Vec2d>& oCurve, double error)
+{
+  int size = data.size();
+  Vector2 *d = new Vector2[size];
+  for(int i=0; i<size; ++i)
+  {
+    d[i][0] = data[i][0];
+    d[i][1] = data[i][1];
+  }
+
+  FitCurve(d,size,error);
+
+  // copy results
+  for(vector<Vector2>::iterator v=_vertices.begin(), vend=_vertices.end();
+  v!=vend;
+  ++v)
+  {
+    oCurve.push_back(Vec2d(v->x(), v->y())) ;
+  }
+  
+}
+
+void FitCurveWrapper::FitCurve(Vector2 *d, int nPts, double error)
+{
+    Vector2 tHat1, tHat2;	/*  Unit tangent vectors at endpoints */
+
+    tHat1 = ComputeLeftTangent(d, 0);
+    tHat2 = ComputeRightTangent(d, nPts - 1);
+    FitCubic(d, 0, nPts - 1, tHat1, tHat2, error);
+}
+
+void FitCurveWrapper::FitCubic(Vector2 *d, int first, int last, Vector2 tHat1, Vector2 tHat2, double error)
+{
+    BezierCurve	bezCurve; /*Control points of fitted Bezier curve*/
+    double	*u;		/*  Parameter values for point  */
+    double	*uPrime;	/*  Improved parameter values */
+    double	maxError;	/*  Maximum fitting error	 */
+    int		splitPoint;	/*  Point to split point set at	 */
+    int		nPts;		/*  Number of points in subset  */
+    double	iterationError; /*Error below which you try iterating  */
+    int		maxIterations = 4; /*  Max times to try iterating  */
+    Vector2	tHatCenter;   	/* Unit tangent vector at splitPoint */
+    int		i;		
+
+    iterationError = error * error;
+    nPts = last - first + 1;
+
+    /*  Use heuristic if region only has two points in it */
+    if (nPts == 2) {
+	    double dist = V2DistanceBetween2Points(&d[last], &d[first]) / 3.0;
+
+		bezCurve = (Vector2 *)malloc(4 * sizeof(Vector2));
+		bezCurve[0] = d[first];
+		bezCurve[3] = d[last];
+		V2Add(&bezCurve[0], V2Scale(&tHat1, dist), &bezCurve[1]);
+		V2Add(&bezCurve[3], V2Scale(&tHat2, dist), &bezCurve[2]);
+		DrawBezierCurve(3, bezCurve);
+		free((void *)bezCurve);
+		return;
+    }
+
+    /*  Parameterize points, and attempt to fit curve */
+    u = ChordLengthParameterize(d, first, last);
+    bezCurve = GenerateBezier(d, first, last, u, tHat1, tHat2);
+
+    /*  Find max deviation of points to fitted curve */
+    maxError = ComputeMaxError(d, first, last, bezCurve, u, &splitPoint);
+    if (maxError < error) {
+		DrawBezierCurve(3, bezCurve);
+		free((void *)u);
+		free((void *)bezCurve);
+		return;
+    }
+
+
+    /*  If error not too large, try some reparameterization  */
+    /*  and iteration */
+    if (maxError < iterationError) {
+		for (i = 0; i < maxIterations; i++) {
+	    	uPrime = Reparameterize(d, first, last, u, bezCurve);
+	    	bezCurve = GenerateBezier(d, first, last, uPrime, tHat1, tHat2);
+	    	maxError = ComputeMaxError(d, first, last,
+				       bezCurve, uPrime, &splitPoint);
+	    	if (maxError < error) {
+			DrawBezierCurve(3, bezCurve);
+			free((void *)u);
+			free((void *)bezCurve);
+			return;
+	    }
+	    free((void *)u);
+	    u = uPrime;
+	}
+    }
+
+    /* Fitting failed -- split at max error point and fit recursively */
+    free((void *)u);
+    free((void *)bezCurve);
+    tHatCenter = ComputeCenterTangent(d, splitPoint);
+    FitCubic(d, first, splitPoint, tHat1, tHatCenter, error);
+    V2Negate(&tHatCenter);
+    FitCubic(d, splitPoint, last, tHatCenter, tHat2, error);
+
+}
+
diff --git a/source/blender/freestyle/intern/geometry/FitCurve.h b/source/blender/freestyle/intern/geometry/FitCurve.h
new file mode 100755
index 00000000000..ed7cbe34780
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/FitCurve.h
@@ -0,0 +1,101 @@
+//
+//  Filename         : FitCurve.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : An Algorithm for Automatically Fitting Digitized Curves
+//                       by Philip J. Schneider
+//                       from "Graphics Gems", Academic Press, 1990
+//  Date of creation : 06/06/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  FITCURVE_H
+# define FITCURVE_H
+
+#include <vector>
+#include "../system/FreestyleConfig.h"
+#include "Geom.h"
+
+using namespace Geometry;
+
+typedef struct Point2Struct {	/* 2d point */
+	double coordinates[2];
+  Point2Struct() {coordinates[0]=0;coordinates[1]=0;}
+  inline double operator[](const int i) const 
+  {
+    return coordinates[i];
+  }
+  inline double& operator[](const int i)
+  {
+    return coordinates[i];
+  }
+  inline double x() const {return coordinates[0];}
+  inline double y() const {return coordinates[1];}
+	} Point2;
+
+typedef Point2 Vector2;
+
+
+
+class LIB_GEOMETRY_EXPORT FitCurveWrapper
+{
+private:
+  std::vector<Vector2> _vertices;
+
+public:
+  FitCurveWrapper();
+  ~FitCurveWrapper();
+
+  /*! Fits a set of 2D data points to a set of Bezier Curve segments
+   *    data
+   *      Input data points
+   *    oCurve
+   *      Control points of the sets of bezier curve segments.
+   *      Each segment is made of 4 points (polynomial degree of curve = 3)
+   *    error
+   *      max error tolerance between resulting curve and input data 
+   */
+  void FitCurve(std::vector<Vec2d>& data, std::vector<Vec2d>& oCurve, double error);
+protected:
+    /* Vec2d	*d;			  Array of digitized points	  */
+    /* int		nPts;		  Number of digitized points	*/
+    /* double	error;		User-defined error squared	*/
+  void FitCurve(Vector2 *d, int nPts, double error);
+    
+  /*! Draws a Bezier curve segment
+   *  n
+   *    degree of curve (=3)
+   *  curve
+   *    bezier segments control points
+   */
+  void DrawBezierCurve(int n, Vector2 *curve);
+  
+  /* Vec2d	*d;			  Array of digitized points */
+  /* int		first, last;	 Indices of first and last pts in region */
+  /* Vec2d tHat1, tHat2;	 Unit tangent vectors at endpoints */
+  /* double	error;		  User-defined error squared	   */
+  void FitCubic(Vector2 *d, int first, int last, Vector2 tHat1, Vector2 tHat2, double error);
+    
+};
+
+#endif // FITCURVE_H
diff --git a/source/blender/freestyle/intern/geometry/Geom.h b/source/blender/freestyle/intern/geometry/Geom.h
new file mode 100755
index 00000000000..ac94213fe98
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Geom.h
@@ -0,0 +1,78 @@
+//
+//  Filename         : Geom.h
+//  Author(s)        : Sylvain Paris
+//                     Emmanuel Turquin
+//                     Stephane Grabli 
+//  Purpose          : Vectors and Matrices (useful type definitions)
+//  Date of creation : 20/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GEOM_H
+# define GEOM_H
+
+# include "VecMat.h"
+# include "../system/Precision.h"
+
+namespace Geometry {
+
+  typedef VecMat::Vec2<unsigned>	Vec2u;
+  typedef VecMat::Vec2<int>		Vec2i;
+  typedef VecMat::Vec2<float>		Vec2f;
+  typedef VecMat::Vec2<double>		Vec2d;
+  typedef VecMat::Vec2<real>		Vec2r;
+
+  typedef VecMat::Vec3<unsigned>	Vec3u;
+  typedef VecMat::Vec3<int>		Vec3i;
+  typedef VecMat::Vec3<float>		Vec3f;
+  typedef VecMat::Vec3<double>		Vec3d;
+  typedef VecMat::Vec3<real>		Vec3r;
+
+  typedef VecMat::HVec3<unsigned>	HVec3u;
+  typedef VecMat::HVec3<int>		HVec3i;
+  typedef VecMat::HVec3<float>		HVec3f;
+  typedef VecMat::HVec3<double>		HVec3d;
+  typedef VecMat::HVec3<real>		HVec3r;
+
+  typedef VecMat::SquareMatrix<unsigned, 2>	Matrix22u;
+  typedef VecMat::SquareMatrix<int, 2>		Matrix22i;
+  typedef VecMat::SquareMatrix<float, 2>	Matrix22f;
+  typedef VecMat::SquareMatrix<double, 2>	Matrix22d;
+  typedef VecMat::SquareMatrix<real, 2>		Matrix22r;
+
+  typedef VecMat::SquareMatrix<unsigned, 3>	Matrix33u;
+  typedef VecMat::SquareMatrix<int, 3>		Matrix33i;
+  typedef VecMat::SquareMatrix<float, 3>	Matrix33f;
+  typedef VecMat::SquareMatrix<double, 3>	Matrix33d;
+  typedef VecMat::SquareMatrix<real, 3>		Matrix33r;
+
+  typedef VecMat::SquareMatrix<unsigned, 4>	Matrix44u;
+  typedef VecMat::SquareMatrix<int, 4>		Matrix44i;
+  typedef VecMat::SquareMatrix<float, 4>	Matrix44f;
+  typedef VecMat::SquareMatrix<double, 4>	Matrix44d;
+  typedef VecMat::SquareMatrix<real, 4>		Matrix44r;
+
+} // end of namespace Geometry
+
+#endif // GEOM_H
diff --git a/source/blender/freestyle/intern/geometry/GeomCleaner.cpp b/source/blender/freestyle/intern/geometry/GeomCleaner.cpp
new file mode 100755
index 00000000000..c148c521a46
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/GeomCleaner.cpp
@@ -0,0 +1,240 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//#if defined(__GNUC__) && (__GNUC__ >= 3)
+//// hash_map is not part of the C++ standard anymore;
+//// hash_map.h has been kept though for backward compatibility
+//# include <hash_map.h>
+//#else
+//# include <hash_map>
+//#endif
+
+#include <stdio.h>
+#include <list>
+#include <map>
+#include "../system/TimeUtils.h"
+#include "GeomCleaner.h"
+
+using namespace std;
+
+
+void GeomCleaner::SortIndexedVertexArray( const float *iVertices, unsigned iVSize, 
+                                          const unsigned *iIndices, unsigned iISize, 
+                                          real **oVertices, 
+                                          unsigned **oIndices)
+{
+  // First, we build a list of IndexVertex:
+  list<IndexedVertex> indexedVertices;
+  unsigned i;
+  for(i=0; i<iVSize; i+= 3)
+  {
+    indexedVertices.push_back(IndexedVertex(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]), i/3));
+  }
+
+  // q-sort
+  indexedVertices.sort();
+
+  // build the indices mapping array:
+  unsigned *mapIndices = new unsigned[iVSize/3];
+  *oVertices = new real[iVSize];
+  list<IndexedVertex>::iterator iv;
+  unsigned newIndex = 0;
+  unsigned vIndex = 0;
+  for(iv=indexedVertices.begin(); iv!=indexedVertices.end(); iv++)
+  {
+    // Build the final results:
+    (*oVertices)[vIndex] = iv->x();
+    (*oVertices)[vIndex+1] = iv->y();
+    (*oVertices)[vIndex+2] = iv->z();
+
+    mapIndices[iv->index()] = newIndex;
+    newIndex++;
+    vIndex+=3;
+  }
+
+  
+  // Build the final index array:
+  *oIndices  = new unsigned[iISize];
+  for(i=0; i<iISize; i++)
+  {
+    (*oIndices)[i] = 3*mapIndices[iIndices[i]/3];
+  }
+
+  delete [] mapIndices;
+}
+
+void GeomCleaner::CompressIndexedVertexArray(const real *iVertices, unsigned iVSize, 
+                                             const unsigned *iIndices, unsigned iISize, 
+                                             real **oVertices, unsigned *oVSize, 
+                                             unsigned **oIndices)
+{
+  // First, we build a list of IndexVertex:
+  vector<Vec3r> vertices;
+  unsigned i;
+  for(i=0; i<iVSize; i+= 3)
+  {
+    vertices.push_back(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]));
+  }
+
+  unsigned *mapVertex = new unsigned[iVSize];
+  vector<Vec3r>::iterator v = vertices.begin();
+  
+  vector<Vec3r> compressedVertices;
+  Vec3r previous = *v;
+  mapVertex[0] = 0;
+  compressedVertices.push_back(vertices.front());
+
+  v++;
+  Vec3r current;
+  i=1;
+  for(; v!=vertices.end(); v++)
+  {
+    current = *v;
+    if(current == previous)
+      mapVertex[i] = compressedVertices.size()-1;
+    else
+    {
+      compressedVertices.push_back(current);
+      mapVertex[i] = compressedVertices.size()-1;
+    }  
+    previous = current;
+    i++;
+  }
+
+  // Builds the resulting vertex array:
+  *oVSize = 3*compressedVertices.size();
+  *oVertices = new real [*oVSize];
+  i=0;
+  for(v=compressedVertices.begin(); v!=compressedVertices.end(); v++)
+  {
+    (*oVertices)[i] = (*v)[0];
+    (*oVertices)[i+1] = (*v)[1];
+    (*oVertices)[i+2] = (*v)[2];
+    i += 3;
+  }
+
+  // Map the index array:
+  *oIndices = new unsigned[iISize];
+  for(i=0; i<iISize; i++)
+  {
+    (*oIndices)[i] = 3*mapVertex[iIndices[i]/3];
+  }
+
+  delete [] mapVertex;
+}
+
+void GeomCleaner::SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize, 
+                                                    const unsigned *iIndices, unsigned iISize, 
+                                                    real **oVertices, unsigned *oVSize, 
+                                                    unsigned **oIndices)
+{
+
+  // tmp arrays used to store the sorted data:
+  real *tmpVertices;
+  unsigned   *tmpIndices;
+
+  Chronometer chrono;
+  // Sort data
+  chrono.start();
+  GeomCleaner::SortIndexedVertexArray(iVertices, iVSize, 
+                                      iIndices, iISize, 
+                                      &tmpVertices, &tmpIndices
+                                      );
+  printf("Sorting: %lf\n", chrono.stop());
+
+  // compress data
+  chrono.start();
+  GeomCleaner::CompressIndexedVertexArray(tmpVertices, iVSize, 
+                                          tmpIndices, iISize, 
+                                          oVertices, oVSize,
+                                          oIndices);
+  printf("Merging: %lf\n", chrono.stop());
+
+  // deallocates memory:
+  delete [] tmpVertices;
+  delete [] tmpIndices;
+}
+
+/*! Defines a hash table used for searching the Cells */
+struct GeomCleanerHasher{
+#define _MUL 950706376UL
+#define _MOD 2147483647UL
+  inline size_t operator() (const Vec3r& p) const {
+    size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
+    res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
+    return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
+  }
+};
+
+void GeomCleaner::CleanIndexedVertexArray(const float *iVertices, unsigned iVSize, 
+					  const unsigned *iIndices, unsigned iISize, 
+					  real **oVertices, unsigned *oVSize, 
+					  unsigned **oIndices)
+{
+  typedef map<Vec3r, unsigned> cleanHashTable;
+  vector<Vec3r> vertices;
+  unsigned i;
+  for(i=0; i<iVSize; i+= 3)
+    vertices.push_back(Vec3r(iVertices[i], iVertices[i+1], iVertices[i+2]));
+  
+  cleanHashTable ht;
+  vector<unsigned> newIndices;
+  vector<Vec3r> newVertices;
+  
+  // elimination of needless points
+  unsigned currentIndex = 0;
+  vector<Vec3r>::const_iterator v = vertices.begin();
+  vector<Vec3r>::const_iterator end = vertices.end();
+  cleanHashTable::const_iterator found;
+  for(; v!=end; v++)
+  {
+    found = ht.find(*v);
+    if(found != ht.end())
+    {
+      // The vertex is already in the new array.
+      newIndices.push_back((*found).second);
+    }
+    else
+    {
+      newVertices.push_back(*v);
+      newIndices.push_back(currentIndex);
+      ht[*v] = currentIndex;
+      currentIndex++;
+    }
+  }
+
+  // creation of oVertices array:
+  *oVSize = 3*newVertices.size();
+  *oVertices = new real[*oVSize];
+  currentIndex = 0;
+  end = newVertices.end();
+  for(v=newVertices.begin(); v!=end ; v++)
+  {
+    (*oVertices)[currentIndex++] = (*v)[0];
+    (*oVertices)[currentIndex++] = (*v)[1];
+    (*oVertices)[currentIndex++] = (*v)[2];
+  }
+
+  // map new indices:
+  *oIndices = new unsigned[iISize];
+  for(i=0; i<iISize; i++)
+    (*oIndices)[i] = 3*newIndices[iIndices[i]/3];
+}
diff --git a/source/blender/freestyle/intern/geometry/GeomCleaner.h b/source/blender/freestyle/intern/geometry/GeomCleaner.h
new file mode 100755
index 00000000000..5fdfda0162a
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/GeomCleaner.h
@@ -0,0 +1,219 @@
+//
+//  Filename         : GeomCleaner.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class to define a cleaner of geometry providing 
+//                     a set of useful tools
+//  Date of creation : 04/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GEOMCLEANER_H
+# define GEOMCLEANER_H
+
+# include "../system/FreestyleConfig.h"
+# include "Geom.h"
+
+using namespace Geometry;
+
+class LIB_GEOMETRY_EXPORT GeomCleaner
+{
+public:
+
+  inline GeomCleaner() {}
+  inline ~GeomCleaner() {}
+
+  /*! Sorts an array of Indexed vertices 
+   *    iVertices
+   *      Array of vertices to sort. It is organized as a
+   *      float series of vertex coordinates: XYZXYZXYZ...
+   *    iVSize
+   *      The size of iVertices array.
+   *    iIndices
+   *      The array containing the vertex indices (used to refer
+   *      to the vertex coordinates in an indexed face). Each 
+   *      element is an unsignedeger multiple of 3.
+   *    iISize
+   *      The size of iIndices array
+   *    oVertices
+   *      Output of sorted vertices. A vertex v1 precedes another one 
+   *      v2 in this array if v1.x<v2.x, or v1.x=v2.x && v1.y < v2.y 
+   *      or v1.x=v2.y && v1.y=v2.y && v1.z < v2.z.
+   *      The array is organized as a 3-float serie giving 
+   *      the vertices coordinates: XYZXYZXYZ...
+   *    oIndices
+   *      Output corresponding to the iIndices array but 
+   *      reorganized in order to match the sorted vertex array.
+   */    
+
+  static void SortIndexedVertexArray(const float *iVertices, unsigned iVSize, 
+                                     const unsigned *iIndices, unsigned iISize, 
+                                     real **oVertices, 
+                                     unsigned **oIndices);
+
+  /*! Compress a SORTED indexed vertex array by eliminating 
+   *  multiple appearing occurences of a single vertex.
+   *    iVertices
+   *      The SORTED vertex array to compress. It is organized as a
+   *      float series of vertex coordinates: XYZXYZXYZ...
+   *    iVSize
+   *      The size of iVertices array.
+   *    iIndices
+   *      The array containing the vertex indices (used to refer
+   *      to the vertex coordinates in an indexed face). Each 
+   *      element is an unsignedeger multiple of 3.
+   *    iISize
+   *      The size of iIndices array
+   *    oVertices
+   *      The vertex array, result of the compression.
+   *      The array is organized as a 3-float serie giving 
+   *      the vertices coordinates: XYZXYZXYZ...
+   *    oVSize
+   *      The size of oVertices.
+   *    oIndices
+   *      The indices array, reorganized to match the compressed 
+   *      oVertices array.
+   */
+
+  static void CompressIndexedVertexArray(const real *iVertices, unsigned iVSize, 
+                                         const unsigned *iIndices, unsigned iISize, 
+                                         real **oVertices, unsigned *oVSize, 
+                                         unsigned **oIndices);
+
+  /*! Sorts and compress an array of indexed vertices.
+   *    iVertices
+   *      The vertex array to sort then compress. It is organized as a
+   *      float series of vertex coordinates: XYZXYZXYZ...
+   *    iVSize
+   *      The size of iVertices array.
+   *    iIndices
+   *      The array containing the vertex indices (used to refer
+   *      to the vertex coordinates in an indexed face). Each 
+   *      element is an unsignedeger multiple of 3.
+   *    iISize
+   *      The size of iIndices array
+   *    oVertices
+   *      The vertex array, result of the sorting-compression.
+   *      The array is organized as a 3-float serie giving 
+   *      the vertices coordinates: XYZXYZXYZ...
+   *    oVSize
+   *      The size of oVertices.
+   *    oIndices
+   *      The indices array, reorganized to match the sorted and compressed 
+   *      oVertices array.
+   */
+
+  static void SortAndCompressIndexedVertexArray(const float *iVertices, unsigned iVSize, 
+                                                const unsigned *iIndices, unsigned iISize, 
+                                                real **oVertices, unsigned *oVSize, 
+                                                unsigned **oIndices);
+
+  /*! Cleans an indexed vertex array. (Identical to 
+   *  SortAndCompress except that we use here a hash
+   *  table to create the new array.)
+   *    iVertices
+   *      The vertex array to sort then compress. It is organized as a
+   *      float series of vertex coordinates: XYZXYZXYZ...
+   *    iVSize
+   *      The size of iVertices array.
+   *    iIndices
+   *      The array containing the vertex indices (used to refer
+   *      to the vertex coordinates in an indexed face). Each 
+   *      element is an unsignedeger multiple of 3.
+   *    iISize
+   *      The size of iIndices array
+   *    oVertices
+   *      The vertex array, result of the sorting-compression.
+   *      The array is organized as a 3-float serie giving 
+   *      the vertices coordinates: XYZXYZXYZ...
+   *    oVSize
+   *      The size of oVertices.
+   *    oIndices
+   *      The indices array, reorganized to match the sorted and compressed 
+   *      oVertices array.
+   */
+
+  static void CleanIndexedVertexArray(const float *iVertices, unsigned iVSize, 
+                                      const unsigned *iIndices, unsigned iISize, 
+                                      real **oVertices, unsigned *oVSize, 
+                                      unsigned **oIndices);
+};
+
+
+/*! Binary operators */
+//inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
+
+/*! Class Indexed Vertex. Used to represent 
+ *  an indexed vertex by storing the vertex 
+ *  coordinates as well as its index
+ */
+class IndexedVertex
+{
+public:
+
+private:
+  Vec3r      _Vector;
+  unsigned        _index;
+public:
+  inline IndexedVertex() {}
+  inline IndexedVertex(Vec3r iVector, unsigned iIndex)
+  {
+    _Vector = iVector;
+    _index = iIndex;
+  }
+  /*! accessors */
+  inline const Vec3r& vector() const {return _Vector;}
+  inline unsigned index() {return _index;}
+  inline real x() {return _Vector[0];}
+  inline real y() {return _Vector[1];}
+  inline real z() {return _Vector[2];}
+  
+  /*! modifiers */
+  inline void setVector(const Vec3r& iVector) {_Vector = iVector;}
+  inline void setIndex(unsigned iIndex) {_index = iIndex;}
+
+  /*! operators */
+  IndexedVertex& operator=(const IndexedVertex& iv)
+  {
+    _Vector = iv._Vector;
+    _index  = iv._index;
+    return *this;
+  }
+  inline real operator[](const unsigned i) {return _Vector[i];}
+  //friend inline bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2);
+  inline bool operator<(const IndexedVertex& v) const
+  {
+    return (_Vector < v._Vector);
+  }
+  inline bool operator==(const IndexedVertex& v)
+  {
+    return (_Vector == v._Vector);
+  }
+};
+
+//bool operator<(const IndexedVertex& iv1, const IndexedVertex& iv2)
+//{
+//  return iv1.operator<(iv2);
+//}
+
+#endif // GEOMCLEANER_H
diff --git a/source/blender/freestyle/intern/geometry/GeomUtils.cpp b/source/blender/freestyle/intern/geometry/GeomUtils.cpp
new file mode 100755
index 00000000000..fd36e81ca77
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/GeomUtils.cpp
@@ -0,0 +1,742 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GeomUtils.h"
+
+namespace GeomUtils {
+
+  // This internal procedure is defined below.
+  bool intersect2dSegPoly(Vec2r* seg,
+			  Vec2r* poly,
+			  unsigned n);
+
+  bool intersect2dSeg2dArea(const Vec2r& min,
+			    const Vec2r& max,
+			    const Vec2r& A,
+			    const Vec2r& B) {
+    Vec2r seg[2];
+    seg[0] = A;
+    seg[1] = B;
+
+    Vec2r poly[5];
+    poly[0][0] = min[0];
+    poly[0][1] = min[1];
+    poly[1][0] = max[0];
+    poly[1][1] = min[1];
+    poly[2][0] = max[0];
+    poly[2][1] = max[1];
+    poly[3][0] = min[0];
+    poly[3][1] = max[1];
+    poly[4][0] = min[0];
+    poly[4][1] = min[1];
+
+    return intersect2dSegPoly(seg, poly, 4);
+  }
+
+  bool include2dSeg2dArea(const Vec2r& min,
+			  const Vec2r& max,
+			  const Vec2r& A,
+			  const Vec2r& B) {
+    if((((max[0] > A[0])&&(A[0] > min[0]))&&((max[0] > B[0])&&(B[0] > min[0])))
+       && (((max[1] > A[1])&&(A[1] > min[1]))&&((max[1] > B[1])&&(B[1] > min[1]))))
+      return true;
+    return false;
+  }
+
+  intersection_test intersect2dSeg2dSeg(const Vec2r& p1,
+					const Vec2r& p2,
+					const Vec2r& p3,
+					const Vec2r& p4,
+					Vec2r& res) {
+    real a1, a2, b1, b2, c1, c2; // Coefficients of line eqns
+    real r1, r2, r3, r4;         // 'Sign' values
+    real denom, num;             // Intermediate values
+
+    // Compute a1, b1, c1, where line joining points p1 and p2
+    // is "a1 x  +  b1 y  +  c1  =  0".
+    a1 = p2[1] - p1[1];
+    b1 = p1[0] - p2[0];
+    c1 = p2[0] * p1[1] - p1[0] * p2[1];
+
+    // Compute r3 and r4.
+    r3 = a1 * p3[0] + b1 * p3[1] + c1;
+    r4 = a1 * p4[0] + b1 * p4[1] + c1;
+
+    // Check signs of r3 and r4.  If both point 3 and point 4 lie on
+    // same side of line 1, the line segments do not intersect.
+    if ( r3 != 0 && r4 != 0 && r3 * r4 > 0.0)
+      return (DONT_INTERSECT);
+
+    // Compute a2, b2, c2
+    a2 = p4[1] - p3[1];
+    b2 = p3[0] - p4[0];
+    c2 = p4[0] * p3[1] - p3[0] * p4[1];
+
+    // Compute r1 and r2
+    r1 = a2 * p1[0] + b2 * p1[1] + c2;
+    r2 = a2 * p2[0] + b2 * p2[1] + c2;
+
+    // Check signs of r1 and r2.  If both point 1 and point 2 lie
+    // on same side of second line segment, the line segments do
+    // not intersect.
+    if ( r1 != 0 && r2 != 0 && r1 * r2 > 0.0)
+      return (DONT_INTERSECT);
+
+    // Line segments intersect: compute intersection point.
+    denom = a1 * b2 - a2 * b1;
+    if (fabs(denom) < M_EPSILON)
+      return (COLINEAR);
+    
+    num = b1 * c2 - b2 * c1;
+    res[0] = num / denom;
+
+    num = a2 * c1 - a1 * c2;
+    res[1] = num / denom;
+
+    return (DO_INTERSECT);
+  }
+
+  intersection_test intersect2dLine2dLine(const Vec2r& p1,
+					  const Vec2r& p2,
+					  const Vec2r& p3,
+					  const Vec2r& p4,
+					  Vec2r& res) {
+    real a1, a2, b1, b2, c1, c2; // Coefficients of line eqns
+    real denom, num;             // Intermediate values
+
+    // Compute a1, b1, c1, where line joining points p1 and p2
+    // is "a1 x  +  b1 y  +  c1  =  0".
+    a1 = p2[1] - p1[1];
+    b1 = p1[0] - p2[0];
+    c1 = p2[0] * p1[1] - p1[0] * p2[1];
+
+    // Compute a2, b2, c2
+    a2 = p4[1] - p3[1];
+    b2 = p3[0] - p4[0];
+    c2 = p4[0] * p3[1] - p3[0] * p4[1];
+
+    // Line segments intersect: compute intersection point.
+    denom = a1 * b2 - a2 * b1;
+    if (fabs(denom) < M_EPSILON)
+      return (COLINEAR);
+
+    num = b1 * c2 - b2 * c1;
+    res[0] = num / denom;
+
+    num = a2 * c1 - a1 * c2;
+    res[1] = num / denom;
+
+    return (DO_INTERSECT);
+  }
+
+  intersection_test intersect2dSeg2dSegParametric(const Vec2r& p1,
+						  const Vec2r& p2,
+						  const Vec2r& p3,
+						  const Vec2r& p4,
+						  real& t,
+						  real& u) {
+    real a1, a2, b1, b2, c1, c2; // Coefficients of line eqns
+    real r1, r2, r3, r4;         // 'Sign' values
+    real denom, num;             // Intermediate values
+
+    // Compute a1, b1, c1, where line joining points p1 and p2
+    // is "a1 x  +  b1 y  +  c1  =  0".
+    a1 = p2[1] - p1[1];
+    b1 = p1[0] - p2[0];
+    c1 = p2[0] * p1[1] - p1[0] * p2[1];
+
+    // Compute r3 and r4.
+    r3 = a1 * p3[0] + b1 * p3[1] + c1;
+    r4 = a1 * p4[0] + b1 * p4[1] + c1;
+
+    // Check signs of r3 and r4.  If both point 3 and point 4 lie on
+    // same side of line 1, the line segments do not intersect.
+    if ( r3 != 0 && r4 != 0 && r3 * r4 > 0.0)
+      return (DONT_INTERSECT);
+
+    // Compute a2, b2, c2
+    a2 = p4[1] - p3[1];
+    b2 = p3[0] - p4[0];
+    c2 = p4[0] * p3[1] - p3[0] * p4[1];
+
+    // Compute r1 and r2
+    r1 = a2 * p1[0] + b2 * p1[1] + c2;
+    r2 = a2 * p2[0] + b2 * p2[1] + c2;
+
+    // Check signs of r1 and r2.  If both point 1 and point 2 lie
+    // on same side of second line segment, the line segments do
+    // not intersect.
+    if ( r1 != 0 && r2 != 0 && r1 * r2 > 0.0)
+      return (DONT_INTERSECT);
+
+    // Line segments intersect: compute intersection point.
+    denom = a1 * b2 - a2 * b1;
+    if (fabs(denom) < M_EPSILON)
+      return (COLINEAR);
+    
+    real d1, d2, e1;
+
+    d1 = p1[1] - p3[1];
+    d2 = p2[1] - p1[1];
+    e1 = p1[0] - p3[0];
+
+    num = -b2 * d1 - a2 * e1;
+    t = num / denom;
+
+    num = -b1 * d1 - a1 * e1;
+    u = num / denom;
+
+    return (DO_INTERSECT);
+  }
+
+  // AABB-triangle overlap test code
+  // by Tomas Akenine-Möller
+  // Function: int triBoxOverlap(real boxcenter[3],
+  //          real boxhalfsize[3],real triverts[3][3]);
+  // History:
+  //   2001-03-05: released the code in its first version
+  //   2001-06-18: changed the order of the tests, faster
+  //
+  // Acknowledgement: Many thanks to Pierre Terdiman for
+  // suggestions and discussions on how to optimize code.
+  // Thanks to David Hunt for finding a ">="-bug!
+
+#define X 0
+#define Y 1
+#define Z 2
+
+#define FINDMINMAX(x0, x1, x2, min, max) \
+  min = max = x0;    \
+  if(x1<min) min=x1; \
+  if(x1>max) max=x1; \
+  if(x2<min) min=x2; \
+  if(x2>max) max=x2;
+
+  //======================== X-tests ========================//
+#define AXISTEST_X01(a, b, fa, fb)                         \
+        p0 = a*v0[Y] - b*v0[Z];                            \
+        p2 = a*v2[Y] - b*v2[Z];                            \
+        if(p0<p2) {min=p0; max=p2;} else {min=p2; max=p0;} \
+        rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z];   \
+        if(min>rad || max<-rad) return 0;
+
+#define AXISTEST_X2(a, b, fa, fb)                          \
+        p0 = a*v0[Y] - b*v0[Z];                            \
+        p1 = a*v1[Y] - b*v1[Z];                            \
+        if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \
+        rad = fa * boxhalfsize[Y] + fb * boxhalfsize[Z];   \
+        if(min>rad || max<-rad) return 0;
+
+  //======================== Y-tests ========================//
+#define AXISTEST_Y02(a, b, fa, fb)                         \
+        p0 = -a*v0[X] + b*v0[Z];                           \
+        p2 = -a*v2[X] + b*v2[Z];                           \
+        if(p0<p2) {min=p0; max=p2;} else {min=p2; max=p0;} \
+        rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z];   \
+        if(min>rad || max<-rad) return 0;
+
+#define AXISTEST_Y1(a, b, fa, fb)                          \
+        p0 = -a*v0[X] + b*v0[Z];                           \
+        p1 = -a*v1[X] + b*v1[Z];                           \
+        if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \
+        rad = fa * boxhalfsize[X] + fb * boxhalfsize[Z];   \
+        if(min>rad || max<-rad) return 0;
+
+  //======================== Z-tests ========================//
+#define AXISTEST_Z12(a, b, fa, fb)                         \
+        p1 = a*v1[X] - b*v1[Y];                            \
+        p2 = a*v2[X] - b*v2[Y];                            \
+        if(p2<p1) {min=p2; max=p1;} else {min=p1; max=p2;} \
+        rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y];   \
+        if(min>rad || max<-rad) return 0;
+
+#define AXISTEST_Z0(a, b, fa, fb)                          \
+        p0 = a*v0[X] - b*v0[Y];                            \
+        p1 = a*v1[X] - b*v1[Y];                            \
+        if(p0<p1) {min=p0; max=p1;} else {min=p1; max=p0;} \
+        rad = fa * boxhalfsize[X] + fb * boxhalfsize[Y];   \
+        if(min>rad || max<-rad) return 0;
+ 
+  // This internal procedure is defined below.
+  bool overlapPlaneBox(Vec3r& normal, real d, Vec3r& maxbox);
+
+  // Use separating axis theorem to test overlap between triangle and box
+  // need to test for overlap in these directions:
+  // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle
+  //    we do not even need to test these)
+  // 2) normal of the triangle
+  // 3) crossproduct(edge from tri, {x,y,z}-directin)
+  //    this gives 3x3=9 more tests
+  bool overlapTriangleBox(Vec3r& boxcenter,
+			  Vec3r& boxhalfsize,
+			  Vec3r triverts[3]) {
+    Vec3r v0, v1, v2, normal, e0, e1, e2;
+    real min, max, d, p0, p1, p2, rad, fex, fey, fez;  
+
+    // This is the fastest branch on Sun
+    // move everything so that the boxcenter is in (0, 0, 0)
+    v0 = triverts[0] - boxcenter;
+    v1 = triverts[1] - boxcenter;
+    v2 = triverts[2] - boxcenter;
+
+    // compute triangle edges
+    e0 = v1 - v0;
+    e1 = v2 - v1;
+    e2 = v0 - v2;
+
+    // Bullet 3:
+    // Do the 9 tests first (this was faster)
+    fex = fabs(e0[X]);
+    fey = fabs(e0[Y]);
+    fez = fabs(e0[Z]);
+    AXISTEST_X01(e0[Z], e0[Y], fez, fey);
+    AXISTEST_Y02(e0[Z], e0[X], fez, fex);
+    AXISTEST_Z12(e0[Y], e0[X], fey, fex);
+
+    fex = fabs(e1[X]);
+    fey = fabs(e1[Y]);
+    fez = fabs(e1[Z]);
+    AXISTEST_X01(e1[Z], e1[Y], fez, fey);
+    AXISTEST_Y02(e1[Z], e1[X], fez, fex);
+    AXISTEST_Z0(e1[Y], e1[X], fey, fex);
+  
+    fex = fabs(e2[X]);
+    fey = fabs(e2[Y]);
+    fez = fabs(e2[Z]);
+    AXISTEST_X2(e2[Z], e2[Y], fez, fey);
+    AXISTEST_Y1(e2[Z], e2[X], fez, fex);
+    AXISTEST_Z12(e2[Y], e2[X], fey, fex);
+
+    // Bullet 1:
+    // first test overlap in the {x,y,z}-directions
+    // find min, max of the triangle each direction, and test for overlap in
+    // that direction -- this is equivalent to testing a minimal AABB around
+    // the triangle against the AABB
+
+    // test in X-direction
+    FINDMINMAX(v0[X], v1[X], v2[X], min, max);
+    if (min > boxhalfsize[X] || max < -boxhalfsize[X])
+      return false;
+
+    // test in Y-direction
+    FINDMINMAX(v0[Y], v1[Y], v2[Y], min, max);
+    if (min > boxhalfsize[Y] || max < -boxhalfsize[Y])
+      return false;
+
+    // test in Z-direction
+    FINDMINMAX(v0[Z], v1[Z], v2[Z], min, max);
+    if(min > boxhalfsize[Z] || max < -boxhalfsize[Z])
+      return false;
+
+    // Bullet 2:
+    // test if the box intersects the plane of the triangle
+    // compute plane equation of triangle: normal * x + d = 0
+    normal = e0 ^ e1;
+    d = -(normal * v0); // plane eq: normal.x + d = 0
+    if (!overlapPlaneBox(normal, d, boxhalfsize))
+      return false;
+  
+    return true; // box and triangle overlaps
+  }
+
+  // Fast, Minimum Storage Ray-Triangle Intersection
+  //
+  // Tomas Möller
+  // Prosolvia Clarus AB
+  // Sweden
+  // tompa@clarus.se
+  //
+  // Ben Trumbore
+  // Cornell University
+  // Ithaca, New York
+  // wbt@graphics.cornell.edu
+
+  bool intersectRayTriangle(Vec3r& orig, Vec3r& dir,
+			    Vec3r& v0, Vec3r& v1, Vec3r& v2,
+			    real& t, real& u, real& v, real epsilon) {
+    Vec3r edge1, edge2, tvec, pvec, qvec;
+    real det, inv_det;
+
+    // find vectors for two edges sharing v0
+    edge1 = v1 - v0;
+    edge2 = v2 - v0;
+
+    // begin calculating determinant - also used to calculate U parameter
+    pvec = dir ^ edge2;
+
+    // if determinant is near zero, ray lies in plane of triangle
+    det = edge1 * pvec;
+
+    // calculate distance from v0 to ray origin
+    tvec = orig - v0;
+    inv_det = 1.0 / det;
+   
+    qvec = tvec ^ edge1;
+      
+    if (det > epsilon) {
+      u = tvec * pvec;
+      if (u < 0.0 || u > det)
+	return false;
+            
+      // calculate V parameter and test bounds
+      v = dir * qvec;
+      if (v < 0.0 || u + v > det)
+	return false;
+    }
+    else if(det < -epsilon) {
+      // calculate U parameter and test bounds
+      u = tvec * pvec;
+      if (u > 0.0 || u < det)
+	return false;
+      
+      // calculate V parameter and test bounds
+      v = dir * qvec;
+      if (v > 0.0 || u + v < det)
+	return false;
+    }
+    else
+      return false;  // ray is parallell to the plane of the triangle
+
+    u *= inv_det;
+    v *= inv_det;
+    t = (edge2 * qvec) * inv_det;
+
+    return true;
+  }
+
+  // Intersection between plane and ray, adapted from Graphics Gems, Didier Badouel
+  intersection_test intersectRayPlane(Vec3r& orig, Vec3r& dir,
+				      Vec3r& norm, real d,
+				      real& t,
+				      real epsilon) { 
+    real denom = norm * dir;
+
+    if(fabs(denom) <= epsilon) { // plane and ray are parallel
+      if(fabs((norm * orig) + d) <= epsilon)
+        return COINCIDENT; // plane and ray are coincident
+      else
+        return COLINEAR;
+    }
+
+    t = -(d + (norm * orig)) / denom;
+
+    if (t < 0.0f)
+      return DONT_INTERSECT;
+
+    return DO_INTERSECT;
+  }
+
+    bool intersectRayBBox(const Vec3r& orig, const Vec3r& dir,   // ray origin and direction
+        const Vec3r& boxMin, const Vec3r& boxMax, // the bbox
+        real t0, real t1,
+        real& tmin, real& tmax,                  // I0=orig+tmin*dir is the first intersection, I1=orig+tmax*dir is the second intersection
+        real epsilon){
+
+            float tymin, tymax, tzmin, tzmax;
+            Vec3r inv_direction(1.0/dir[0], 1.0/dir[1], 1.0/dir[2]);
+            int sign[3];
+            sign[0] = (inv_direction.x() < 0);
+            sign[1] = (inv_direction.y() < 0);
+            sign[2] = (inv_direction.z() < 0);
+
+            Vec3r bounds[2];
+            bounds[0] = boxMin;
+            bounds[1] = boxMax;
+
+            tmin = (bounds[sign[0]].x() - orig.x()) * inv_direction.x();
+            tmax = (bounds[1-sign[0]].x() - orig.x()) * inv_direction.x();
+            tymin = (bounds[sign[1]].y() - orig.y()) * inv_direction.y();
+            tymax = (bounds[1-sign[1]].y() - orig.y()) * inv_direction.y();
+            if ( (tmin > tymax) || (tymin > tmax) )
+                return false;
+            if (tymin > tmin)
+                tmin = tymin;
+            if (tymax < tmax)
+                tmax = tymax;
+            tzmin = (bounds[sign[2]].z() - orig.z()) * inv_direction.z();
+            tzmax = (bounds[1-sign[2]].z() - orig.z()) * inv_direction.z();
+            if ( (tmin > tzmax) || (tzmin > tmax) )
+                return false;
+            if (tzmin > tmin)
+                tmin = tzmin;
+            if (tzmax < tmax)
+                tmax = tzmax;
+            return ( (tmin < t1) && (tmax > t0) );
+        }
+
+  // Checks whether 3D points p lies inside or outside of the triangle ABC
+  bool includePointTriangle(Vec3r& P,
+			    Vec3r& A,
+			    Vec3r& B,
+			    Vec3r& C) {
+    Vec3r AB(B - A);
+    Vec3r BC(C - B);
+    Vec3r CA(A - C);
+    Vec3r AP(P - A);
+    Vec3r BP(P - B);
+    Vec3r CP(P - C);
+
+    Vec3r N(AB ^ BC); // triangle's normal
+
+    N.normalize();
+
+    Vec3r J(AB ^ AP), K(BC ^ BP), L(CA ^ CP);
+    J.normalize();
+    K.normalize();
+    L.normalize();
+
+    if(J * N < 0)
+      return false; // on the right of AB
+
+    if(K * N < 0)
+      return false; // on the right of BC
+
+    if(L * N < 0)
+      return false; // on the right of CA
+
+    return true;
+  }
+
+  void transformVertex(const Vec3r& vert,
+		       const Matrix44r& matrix,
+		       Vec3r& res) {
+    HVec3r hvert(vert), res_tmp;    
+    real scale;
+    for (unsigned j = 0; j < 4; j++) {
+      scale = hvert[j];
+      for (unsigned i = 0; i < 4; i++)
+        res_tmp[i] += matrix(i, j) * scale;
+    }
+    
+    res[0] = res_tmp.x();
+    res[1] = res_tmp.y();
+    res[2] = res_tmp.z();
+  }
+  
+  void transformVertices(const vector<Vec3r>& vertices,
+			 const Matrix44r& trans,
+			 vector<Vec3r>& res) {
+    for (vector<Vec3r>::const_iterator v = vertices.begin();
+	 v != vertices.end();
+	 v++) {
+      Vec3r *res_tmp = new Vec3r;
+      transformVertex(*v, trans, *res_tmp);
+      res.push_back(*res_tmp);
+    }
+  }
+
+  Vec3r rotateVector(const Matrix44r& mat, const Vec3r& v) {
+    Vec3r res;
+    for (unsigned i = 0; i < 3; i++) {
+      res[i] = 0;
+      for (unsigned j = 0; j < 3; j++)
+	res[i] += mat(i, j) * v[j];
+    }
+    res.normalize();
+    return res;
+  }
+
+  // This internal procedure is defined below.
+  void fromCoordAToCoordB(const Vec3r& p,
+			  Vec3r& q,
+			  const real transform[4][4]);
+
+  void fromWorldToCamera(const Vec3r& p,
+			 Vec3r& q,
+			 const real model_view_matrix[4][4]) {
+    fromCoordAToCoordB(p, q, model_view_matrix);
+  }
+
+  void fromCameraToRetina(const Vec3r& p,
+			  Vec3r& q,
+			  const real projection_matrix[4][4]) {
+    fromCoordAToCoordB(p, q, projection_matrix);
+  }
+
+  void fromRetinaToImage(const Vec3r& p,
+			 Vec3r& q,
+			 const int viewport[4]) {
+    // winX:
+    q[0] = viewport[0] + viewport[2] * (p[0] + 1.0) / 2.0;
+
+    // winY:
+    q[1] = viewport[1] + viewport[3] * (p[1] + 1.0) / 2.0;
+
+    // winZ:
+    q[2] = (p[2] + 1.0) / 2.0;
+  }
+
+  void fromWorldToImage(const Vec3r& p,
+			Vec3r& q,
+			const real model_view_matrix[4][4],
+			const real projection_matrix[4][4],
+			const int viewport[4]) {
+    Vec3r p1, p2;
+    fromWorldToCamera(p, p1, model_view_matrix);
+    fromCameraToRetina(p1, p2, projection_matrix);
+    fromRetinaToImage(p2, q, viewport);
+    q[2] = p1[2];
+  }
+
+  void fromWorldToImage(const Vec3r& p,
+			Vec3r& q,
+			const real transform[4][4],
+			const int viewport[4]) {
+    fromCoordAToCoordB(p, q, transform);
+
+    // winX:
+    q[0] = viewport[0] + viewport[2] * (q[0] + 1.0) / 2.0;
+
+    //winY:
+    q[1] = viewport[1] + viewport[3] * (q[1] + 1.0) / 2.0;
+  }
+
+  void fromImageToRetina(const Vec3r& p,
+			 Vec3r& q,
+			 const int viewport[4]) {
+    q = p;
+    q[0] = 2.0 * (q[0] - viewport[0]) / viewport[2] - 1;
+    q[1] = 2.0 * (q[1] - viewport[1]) / viewport[3] - 1;
+  }
+
+  void fromRetinaToCamera(const Vec3r& p,
+			  Vec3r& q,
+			  real z,
+			  const real projection_matrix[4][4]) {
+    q[0] = (-p[0] * z) / projection_matrix[0][0];
+    q[1] = (-p[1] * z) / projection_matrix[1][1];
+    q[2] = z;
+  }
+
+  void fromCameraToWorld(const Vec3r& p,
+			 Vec3r& q,
+			 const real model_view_matrix[4][4]) {
+
+    real translation[3] = { model_view_matrix[0][3],
+			      model_view_matrix[1][3],
+			      model_view_matrix[2][3] };
+    for (unsigned i = 0; i < 3; i++) {
+      q[i] = 0.0;
+      for (unsigned short j = 0; j < 3; j++)
+	q[i] += model_view_matrix[j][i] * (p[j] - translation[j]);
+    }
+  }
+
+
+  //
+  // Internal code
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Copyright 2001, softSurfer (www.softsurfer.com)
+  // This code may be freely used and modified for any purpose
+  // providing that this copyright notice is included with it.
+  // SoftSurfer makes no warranty for this code, and cannot be held
+  // liable for any real or imagined damage resulting from its use.
+  // Users of this code must verify correctness for their application.
+
+#define perp(u,v)  ((u)[0] * (v)[1] - (u)[1] * (v)[0])   // 2D perp product
+
+  inline bool intersect2dSegPoly(Vec2r* seg,
+				 Vec2r* poly,
+				 unsigned n) {
+    if (seg[0] == seg[1])
+      return false;
+
+    real  tE = 0;             // the maximum entering segment parameter
+    real  tL = 1;             // the minimum leaving segment parameter
+    real  t, N, D;            // intersect parameter t = N / D
+    Vec2r dseg;                // the segment direction vector
+    dseg = seg[1] - seg[0];
+    Vec2r e;                   // edge vector
+
+    for (unsigned i = 0; i < n; i++) { // process polygon edge poly[i]poly[i+1]
+      e = poly[i+1] - poly[i];
+      N = perp(e, seg[0] - poly[i]);
+      D = -perp(e, dseg);
+      if (fabs(D) < M_EPSILON) {
+	if (N < 0)
+	  return false;
+	else
+	  continue;
+      }
+
+      t = N / D;
+      if (D < 0) {       // segment seg is entering across this edge
+	if (t > tE) {    // new max tE
+	  tE = t;
+	  if (tE > tL)   // seg enters after leaving polygon
+	    return false;
+	}
+      }
+      else {             // segment seg is leaving across this edge
+	if (t < tL) {    // new min tL
+	  tL = t;
+	  if (tL < tE)   // seg leaves before entering polygon
+	    return false;
+	}
+      }
+    }
+
+    // tE <= tL implies that there is a valid intersection subsegment
+    return true;
+  }
+
+  inline bool overlapPlaneBox(Vec3r& normal, real d, Vec3r& maxbox) {
+    Vec3r vmin, vmax;
+
+    for(unsigned q = X; q <= Z; q++) {
+	if(normal[q] > 0.0f) {
+	  vmin[q] = -maxbox[q];
+	  vmax[q] = maxbox[q];
+	}
+	else {
+	  vmin[q] = maxbox[q];
+	  vmax[q] = -maxbox[q];
+	}
+    }
+    if((normal * vmin) + d > 0.0f)
+      return false;
+    if((normal * vmax) + d >= 0.0f)
+      return true;
+    return false;
+  }
+
+  inline void fromCoordAToCoordB(const Vec3r&p,
+				 Vec3r& q,
+				 const real transform[4][4]) {
+    HVec3r hp(p);
+    HVec3r hq(0, 0, 0, 0);
+
+    for (unsigned i = 0; i < 4; i++)
+      for (unsigned j = 0; j < 4; j++)
+	hq[i] += transform[i][j] * hp[j];
+
+    if(hq[3] == 0) {
+      q = p;
+      return;
+    }
+
+    for (unsigned k = 0; k < 3; k++)
+      q[k] = hq[k] / hq[3];
+  }
+
+} // end of namespace GeomUtils
diff --git a/source/blender/freestyle/intern/geometry/GeomUtils.h b/source/blender/freestyle/intern/geometry/GeomUtils.h
new file mode 100755
index 00000000000..53c94c22f8b
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/GeomUtils.h
@@ -0,0 +1,309 @@
+//
+//  Filename         : GeomUtils.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Various tools for geometry
+//  Date of creation : 12/04/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GEOMUTILS_H
+# define GEOMUTILS_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "Geom.h"
+
+using namespace std;
+using namespace Geometry;
+
+namespace GeomUtils {
+
+  //
+  // Templated procedures
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  /*! Computes the distance from a point P to a segment AB */
+  template<class T>
+  real distPointSegment( const T& P, const T& A , const T& B) { 
+    T AB, AP, BP;
+    AB = B - A;
+    AP = P - A;
+    BP = P - B;
+
+    real c1(AB * AP);
+    if (c1 <= 0)
+      return AP.norm();
+
+    real c2(AB * AB);
+    if (c2 <= c1)
+      return BP.norm();
+
+    real b = c1 / c2;
+    T Pb, PPb;
+    Pb = A + b * AB;
+    PPb = P - Pb;
+
+    return PPb.norm();
+  } 
+
+  //
+  // Non-templated procedures
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  typedef enum {
+    DONT_INTERSECT,
+    DO_INTERSECT,
+    COLINEAR,
+    COINCIDENT
+  } intersection_test;
+
+  LIB_GEOMETRY_EXPORT
+  intersection_test intersect2dSeg2dSeg(const Vec2r& p1, const Vec2r& p2, // first segment
+					const Vec2r& p3, const Vec2r& p4, // second segment
+					Vec2r& res);                      // found intersection point
+
+  LIB_GEOMETRY_EXPORT
+  intersection_test intersect2dLine2dLine(const Vec2r& p1, const Vec2r& p2, // first segment
+					  const Vec2r& p3, const Vec2r& p4, // second segment
+					  Vec2r& res);                      // found intersection point
+
+  LIB_GEOMETRY_EXPORT
+  intersection_test intersect2dSeg2dSegParametric(const Vec2r& p1, const Vec2r& p2, // first segment
+						  const Vec2r& p3, const Vec2r& p4, // second segment
+						  real& t,                          // I = P1 + t * P1P2)
+						  real& u);                         // I = P3 + u * P3P4
+
+  /*! check whether a 2D segment intersect a 2D region or not */
+  LIB_GEOMETRY_EXPORT
+  bool intersect2dSeg2dArea(const Vec2r& min,
+			    const Vec2r& max,
+			    const Vec2r& A,
+			    const Vec2r& B);
+  
+  /*! check whether a 2D segment is included in a 2D region or not */
+  LIB_GEOMETRY_EXPORT
+  bool include2dSeg2dArea(const Vec2r& min,
+			  const Vec2r& max,
+			  const Vec2r& A,
+			  const Vec2r& B);
+
+  /*! Box-triangle overlap test, adapted from Tomas Akenine-Möller code */
+  LIB_GEOMETRY_EXPORT
+  bool overlapTriangleBox(Vec3r& boxcenter,
+			  Vec3r& boxhalfsize,
+			  Vec3r triverts[3]);
+
+  /*! Fast, Minimum Storage Ray-Triangle Intersection,
+   * adapted from Tomas Möller and Ben Trumbore code.
+   */
+  LIB_GEOMETRY_EXPORT
+  bool intersectRayTriangle(Vec3r& orig, Vec3r& dir,
+			    Vec3r& v0, Vec3r& v1, Vec3r& v2,
+			    real& t,                   // I = orig + t * dir
+                real& u, real& v,          // I = (1-u-v)*v0+u*v1+v*v2
+			    real epsilon = M_EPSILON); // the epsilon to use
+
+  /*! Intersection between plane and ray
+   * adapted from Graphics Gems, Didier Badouel 
+   */
+  LIB_GEOMETRY_EXPORT
+  intersection_test intersectRayPlane(Vec3r& orig, Vec3r& dir,   // ray origin and direction
+				      Vec3r& norm, real d,       // plane's normal and offset (plane = { P / P.N + d = 0 })
+				      real& t,                   // I = orig + t * dir
+				      real epsilon = M_EPSILON); // the epsilon to use
+
+ /*! Intersection Ray-Bounding box (axis aligned).
+  *  Adapted from Williams et al, "An Efficient Robust Ray-Box Intersection Algorithm", 
+  *  JGT 10:1 (2005), pp. 49-54.
+  *  Returns
+  */
+  LIB_GEOMETRY_EXPORT
+      bool intersectRayBBox(const Vec3r& orig, const Vec3r& dir,   // ray origin and direction
+      const Vec3r& boxMin, const Vec3r& boxMax, // the bbox
+      real t0, real t1,     // the interval in which at least on of the intersections must happen
+      real& tmin, real& tmax,                  // Imin=orig+tmin*dir is the first intersection, Imax=orig+tmax*dir is the second intersection
+      real epsilon = M_EPSILON); // the epsilon to use
+
+
+  /*! Checks whether 3D point P lies inside or outside of the triangle ABC */
+  LIB_GEOMETRY_EXPORT
+  bool includePointTriangle(Vec3r& P,
+			    Vec3r& A,
+			    Vec3r& B,
+			    Vec3r& C);
+
+  LIB_GEOMETRY_EXPORT
+  void transformVertex(const Vec3r& vert,
+		       const Matrix44r& matrix,
+		       Vec3r& res);
+  
+  LIB_GEOMETRY_EXPORT
+  void transformVertices(const vector<Vec3r>& vertices,
+			 const Matrix44r& trans,
+			 vector<Vec3r>& res);
+
+  LIB_GEOMETRY_EXPORT
+  Vec3r rotateVector(const Matrix44r& mat, const Vec3r& v);
+
+  //
+  // Coordinates systems changing procedures
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  /*! From world to image
+   *  p
+   *    point's coordinates expressed in world coordinates system
+   *  q
+   *    vector in which the result will be stored
+   *  model_view_matrix
+   *    The model view matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   *  projection_matrix
+   *    The projection matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   *  viewport
+   *    The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromWorldToImage(const Vec3r& p,
+			Vec3r& q,
+			const real model_view_matrix[4][4],
+			const real projection_matrix[4][4],
+			const int viewport[4]);
+
+  /*! From world to image
+   *  p
+   *    point's coordinates expressed in world coordinates system
+   *  q
+   *    vector in which the result will be stored
+   *  transform
+   *    The transformation matrix (gathering model view and projection), 
+   *    expressed in line major order (OpenGL matrices are column major ordered)
+   *  viewport
+   *    The viewport: x,y coordinates followed by width and height (OpenGL like viewport)
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromWorldToImage(const Vec3r& p,
+			Vec3r& q,
+			const real transform[4][4],
+			const int viewport[4]);
+
+  /*! Projects from world coordinates to camera coordinates 
+   *  Returns the point's coordinates expressed in the camera's 
+   *  coordinates system.
+   *  p
+   *    point's coordinates expressed in world coordinates system
+   *  q
+   *    vector in which the result will be stored
+   *  model_view_matrix
+   *    The model view matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromWorldToCamera(const Vec3r& p,
+			 Vec3r& q,
+			 const real model_view_matrix[4][4]);
+  
+  /*! Projects from World Coordinates to retina coordinates
+   *  Returns the point's coordinates expressed in Retina system.
+   *  p
+   *    point's coordinates expressed in camera system
+   *  q
+   *    vector in which the result will be stored
+   *  projection_matrix
+   *    The projection matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromCameraToRetina(const Vec3r& p,
+			  Vec3r& q,
+			  const real projection_matrix[4][4]);
+  
+  /*! From retina to image.
+   *  Returns the coordinates expressed in Image coorinates system.
+   *  p
+   *    point's coordinates expressed in retina system
+   *  q
+   *    vector in which the result will be stored
+   *  viewport
+   *    The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromRetinaToImage(const Vec3r& p,
+			 Vec3r& q,
+			 const int viewport[4]);
+  
+  /*! From image to retina
+   *  p
+   *    point's coordinates expressed in image system
+   *  q
+   *    vector in which the result will be stored
+   *  viewport
+   *    The viewport: x,y coordinates followed by width and height (OpenGL like viewport).
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromImageToRetina(const Vec3r& p,
+			 Vec3r& q,
+			 const int viewport[4]);
+ 
+  /*! computes the coordinates of q in the camera coordinates system, 
+   *  using the known z coordinates of the 3D point. 
+   *  That means that this method does not inverse any matrices, 
+   *  it only computes X and Y from x,y and Z)
+   *  p
+   *    point's coordinates expressed in retina system
+   *  q
+   *    vector in which the result will be stored
+   *  projection_matrix
+   *    The projection matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromRetinaToCamera(const Vec3r& p,
+			  Vec3r& q,
+			  real z,
+			  const real projection_matrix[4][4]);
+
+  /*! Projects from camera coordinates to world coordinates
+   *  Returns the point's coordinates expressed in the world's 
+   *  coordinates system.
+   *  p
+   *    point's coordinates expressed in the camera coordinates system
+   *  q
+   *    vector in which the result will be stored
+   *  model_view_matrix
+   *    The model view matrix expressed in line major order (OpenGL
+   *    matrices are column major ordered)
+   */
+  LIB_GEOMETRY_EXPORT
+  void fromCameraToWorld(const Vec3r& p,
+			 Vec3r& q,
+			 const real model_view_matrix[4][4]);
+
+} // end of namespace GeomUtils
+
+#endif // GEOMUTILS_H
diff --git a/source/blender/freestyle/intern/geometry/Grid.cpp b/source/blender/freestyle/intern/geometry/Grid.cpp
new file mode 100755
index 00000000000..2477227c410
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Grid.cpp
@@ -0,0 +1,388 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Grid.h"
+#include "BBox.h"
+#include <cassert>
+#include <stdexcept>
+
+// Grid Visitors
+/////////////////
+void allOccludersGridVisitor::examineOccluder(Polygon3r *occ){
+    occluders_.push_back(occ);
+}
+
+bool inBox(const Vec3r& inter, const Vec3r& box_min, const Vec3r& box_max){
+    if(((inter.x()>=box_min.x()) && (inter.x() <box_max.x()))
+        && ((inter.y()>=box_min.y()) && (inter.y() <box_max.y()))
+        && ((inter.z()>=box_min.z()) && (inter.z() <box_max.z()))
+        ){
+            return true;
+        }
+        return false;
+}
+void firstIntersectionGridVisitor::examineOccluder(Polygon3r *occ){
+
+    // check whether the edge and the polygon plane are coincident:
+    //-------------------------------------------------------------
+    //first let us compute the plane equation.
+    Vec3r v1(((occ)->getVertices())[0]);           
+    Vec3d normal((occ)->getNormal());
+    //soc unused - double d = -(v1 * normal);
+
+    double tmp_u, tmp_v, tmp_t;
+    if((occ)->rayIntersect(ray_org_, ray_dir_, tmp_t, tmp_u, tmp_v)){
+        if (fabs(ray_dir_ * normal) > 0.0001){
+            // Check whether the intersection is in the cell:
+            if(inBox(ray_org_+tmp_t*ray_dir_/ray_dir_.norm(), current_cell_->getOrigin(), current_cell_->getOrigin()+cell_size_)){
+
+                //Vec3d bboxdiag(_scene3d->bbox().getMax()-_scene3d->bbox().getMin());
+                //if ((t>1.0E-06*(min(min(bboxdiag.x(),bboxdiag.y()),bboxdiag.z()))) && (t<raylength)){
+                if(tmp_t < t_){
+                    occluder_ = occ;
+                    u_ = tmp_u;
+                    v_ = tmp_v;
+                    t_ = tmp_t;
+                }
+            }else{
+                occ->userdata2 = 0;
+            }
+        }
+    }
+}
+
+bool firstIntersectionGridVisitor::stop(){
+    if(occluder_)
+        return true;
+    return false;
+}
+
+// Grid
+/////////////////
+
+void Grid::clear() {
+  if (_occluders.size() != 0) {
+    for(OccludersSet::iterator it = _occluders.begin();
+	it != _occluders.end();
+	it++) {
+      delete (*it);
+    }
+    _occluders.clear();
+  }
+
+  _size = Vec3r(0, 0, 0);
+  _cell_size = Vec3r(0, 0, 0);
+  _orig = Vec3r(0, 0, 0);
+  _cells_nb = Vec3u(0, 0, 0);
+  //_ray_occluders.clear();
+}       
+
+void Grid::configure(const Vec3r& orig,
+		     const Vec3r& size,
+		     unsigned nb) {
+                 
+  _orig = orig;
+ Vec3r tmpSize=size;
+  // Compute the volume of the desired grid
+  real grid_vol = size[0] * size[1] * size[2];
+
+  if(grid_vol == 0){
+    double min=DBL_MAX;
+    int index=0;
+    int nzeros=0;
+    for(int i=0;i<3;++i){
+        if(size[i] == 0){
+            ++nzeros;
+            index=i;
+        }
+        if((size[i]!=0) && (min>size[i])){
+            min=size[i];
+        }
+    }
+    if(nzeros>1){
+        throw std::runtime_error("Warning: the 3D grid has more than one null dimension");
+    }
+    tmpSize[index]=min;
+    _orig[index] = _orig[index]-min/2;
+  }
+  // Compute the desired volume of a single cell
+  real cell_vol = grid_vol / nb;
+  // The edge of such a cubic cell is cubic root of cellVolume
+  real edge = pow(cell_vol, 1.0 / 3.0);
+
+  // We compute the number of cells par edge
+  // such as we cover at least the whole box.
+  unsigned i;
+  for (i = 0; i < 3; i++)
+    _cells_nb[i] = (unsigned)floor(tmpSize[i] / edge) + 1;
+
+  _size = tmpSize;
+
+  for(i = 0; i < 3; i++)
+    _cell_size[i] = _size[i] / _cells_nb[i];
+}
+
+void Grid::insertOccluder(Polygon3r* occluder) {
+  const vector<Vec3r> vertices = occluder->getVertices();
+  if (vertices.size() == 0)
+    return;
+
+  // add this occluder to the grid's occluders list
+  addOccluder(occluder);
+
+  // find the bbox associated to this polygon
+  Vec3r min, max;
+  occluder->getBBox(min, max);
+
+  // Retrieve the cell x, y, z cordinates associated with these min and max
+  Vec3u imax, imin;
+  getCellCoordinates(max, imax);
+  getCellCoordinates(min, imin);
+  
+  // We are now going to fill in the cells overlapping with the
+  // polygon bbox.
+  // If the polygon is a triangle (most of cases), we also
+  // check for each of these cells if it is overlapping with
+  // the triangle in order to only fill in the ones really overlapping
+  // the triangle.
+
+  unsigned i, x, y, z;
+  vector<Vec3r>::const_iterator it;
+  Vec3u coord;
+
+  if (vertices.size() == 3) { // Triangle case
+    Vec3r triverts[3];
+    i = 0;
+    for(it = vertices.begin();
+	it != vertices.end();
+	it++) {
+      triverts[i] = Vec3r(*it);
+      i++;
+    }
+
+    Vec3r boxmin, boxmax;
+
+    for (z = imin[2]; z <= imax[2]; z++)
+      for (y = imin[1]; y <= imax[1]; y++)
+	for (x = imin[0]; x <= imax[0]; x++) {
+	  coord[0] = x;
+	  coord[1] = y;
+	  coord[2] = z;
+	  // We retrieve the box coordinates of the current cell
+	  getCellBox(coord, boxmin, boxmax);
+	  // We check whether the triangle and the box ovewrlap:
+	  Vec3r boxcenter((boxmin + boxmax) / 2.0);
+	  Vec3r boxhalfsize(_cell_size / 2.0);
+	  if (GeomUtils::overlapTriangleBox(boxcenter, boxhalfsize, triverts)) {
+	    // We must then create the Cell and add it to the cells list
+	    // if it does not exist yet.
+	    // We must then add the occluder to the occluders list of this cell.
+	    Cell* cell = getCell(coord);
+	    if (!cell) {
+	      cell = new Cell(boxmin);
+	      fillCell(coord, *cell);
+	    }
+	    cell->addOccluder(occluder);
+	  }
+	}
+  }
+  else { // The polygon is not a triangle, we add all the cells overlapping the polygon bbox.
+    for (z = imin[2]; z <= imax[2]; z++)
+      for (y = imin[1]; y <= imax[1]; y++)
+	for (x = imin[0]; x <= imax[0]; x++) {
+	  coord[0] = x;
+	  coord[1] = y;
+	  coord[2] = z;
+	  Cell* cell = getCell(coord);
+	  if (!cell) {
+	    Vec3r orig;
+	    getCellOrigin(coord, orig);
+	    cell = new Cell(orig);
+	    fillCell(coord, *cell);
+	  }
+	  cell->addOccluder(occluder);
+	}
+  }
+}
+
+bool Grid::nextRayCell(Vec3u& current_cell, Vec3u& next_cell) {
+  next_cell = current_cell;
+  real t_min, t;
+  unsigned i;
+ 
+  t_min = FLT_MAX;    // init tmin with handle of the case where one or 2 _u[i] = 0. 
+  unsigned coord = 0; // predominant coord(0=x, 1=y, 2=z)
+
+
+  // using a parametric equation of
+  // a line : B = A + t u, we find
+  // the tx, ty and tz respectively coresponding
+  // to the intersections with the plans:
+  // x = _cell_size[0], y = _cell_size[1], z = _cell_size[2]
+  for (i = 0; i < 3; i++) {
+    if (_ray_dir[i] == 0)
+      continue;
+    if (_ray_dir[i] > 0)
+      t = (_cell_size[i] - _pt[i]) / _ray_dir[i];
+    else
+      t = -_pt[i] / _ray_dir[i];
+    if (t < t_min) {
+      t_min = t;
+      coord = i;
+    }
+  }
+
+  // We use the parametric line equation and
+  // the found t (tamx) to compute the
+  // B coordinates:
+  Vec3r pt_tmp(_pt);
+  _pt = pt_tmp + t_min * _ray_dir;
+    
+  // We express B coordinates in the next cell
+  // coordinates system. We just have to
+  // set the coordinate coord of B to 0
+  // of _CellSize[coord] depending on the sign
+  // of _u[coord]
+  if (_ray_dir[coord] > 0) {
+    next_cell[coord]++;
+    _pt[coord] -= _cell_size[coord];
+    // if we are out of the grid, we must stop
+    if (next_cell[coord] >= _cells_nb[coord])
+      return false;
+  }
+  else {
+    int tmp = next_cell[coord] - 1;
+    _pt[coord] = _cell_size[coord];
+    if (tmp < 0)
+      return false;
+    next_cell[coord]--;
+  }
+
+  _t += t_min;
+  if (_t >= _t_end)
+    return false;
+
+  return true;
+}
+
+void Grid::castRay(const Vec3r& orig,
+		   const Vec3r& end,
+		   OccludersSet& occluders,
+		   unsigned timestamp) {
+  initRay(orig, end, timestamp);
+  allOccludersGridVisitor visitor(occluders);
+  castRayInternal(visitor);
+}
+
+void Grid::castInfiniteRay(const Vec3r& orig,
+			   const Vec3r& dir,
+			   OccludersSet& occluders,
+			   unsigned timestamp) {
+  Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
+  bool inter = initInfiniteRay(orig, dir, timestamp);
+  if(!inter)
+      return;
+  allOccludersGridVisitor visitor(occluders);
+  castRayInternal(visitor);
+}
+  
+Polygon3r* Grid::castRayToFindFirstIntersection(const Vec3r& orig,
+                   const Vec3r& dir,
+                   double& t,
+                   double& u,
+                   double& v,
+                   unsigned timestamp){
+    Polygon3r *occluder = 0;
+    Vec3r end = Vec3r(orig + FLT_MAX * dir / dir.norm());
+    bool inter = initInfiniteRay(orig, dir, timestamp);
+    if(!inter){
+        return 0;
+    }
+    firstIntersectionGridVisitor visitor(orig,dir,_cell_size);
+    castRayInternal(visitor);
+    occluder = visitor.occluder();
+    t = visitor.t_;
+    u = visitor.u_;
+    v = visitor.v_;
+    return occluder;
+}
+
+void Grid::initRay (const Vec3r &orig,
+		    const Vec3r& end,
+		    unsigned timestamp) {
+  _ray_dir = end - orig;
+  _t_end = _ray_dir.norm();
+  _t = 0;
+  _ray_dir.normalize();
+  _timestamp = timestamp;
+
+  for(unsigned i = 0; i < 3; i++) {
+    _current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
+    //soc unused - unsigned u = _current_cell[i];
+    _pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
+  }
+  //_ray_occluders.clear();
+
+}
+
+bool Grid::initInfiniteRay (const Vec3r &orig,
+		    const Vec3r& dir,
+		    unsigned timestamp) {
+  _ray_dir = dir;
+  _t_end = FLT_MAX;
+  _t = 0;
+  _ray_dir.normalize();
+  _timestamp = timestamp;
+
+  // check whether the origin is in or out the box:
+  Vec3r boxMin(_orig);
+  Vec3r boxMax(_orig+_size);
+  BBox<Vec3r> box(boxMin, boxMax);
+  if(box.inside(orig)){
+      for(unsigned i = 0; i < 3; i++) {
+          _current_cell[i] = (unsigned)floor((orig[i] - _orig[i]) / _cell_size[i]);
+          //soc unused - unsigned u = _current_cell[i];
+          _pt[i] = orig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
+      }
+  }else{
+      // is the ray intersecting the box?
+      real tmin(-1.0), tmax(-1.0);
+      if(GeomUtils::intersectRayBBox(orig, _ray_dir, boxMin, boxMax, 0, _t_end, tmin, tmax)){
+        assert(tmin != -1.0);
+        Vec3r newOrig = orig + tmin*_ray_dir;
+        for(unsigned i = 0; i < 3; i++) {
+            _current_cell[i] = (unsigned)floor((newOrig[i] - _orig[i]) / _cell_size[i]);
+            if(_current_cell[i] == _cells_nb[i])
+                _current_cell[i] = _cells_nb[i] - 1;
+            //soc unused - unsigned u = _current_cell[i];
+            _pt[i] = newOrig[i] - _orig[i] - _current_cell[i] * _cell_size[i];
+        }
+
+      }else{
+          return false;
+      }
+  }
+  //_ray_occluders.clear();
+
+  return true;
+
+}
+
diff --git a/source/blender/freestyle/intern/geometry/Grid.h b/source/blender/freestyle/intern/geometry/Grid.h
new file mode 100755
index 00000000000..fdca13d4ca4
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Grid.h
@@ -0,0 +1,362 @@
+//
+//  Filename         : Grid.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Base class to define a cell grid surrounding
+//                     the bounding box of the scene
+//  Date of creation : 30/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GRID_H
+# define GRID_H
+
+# include <float.h>
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "GeomUtils.h"
+# include "Geom.h"
+# include "Polygon.h"
+
+using namespace std;
+using namespace Geometry;
+
+typedef vector<Polygon3r*>	OccludersSet;
+
+
+//
+// Class to define cells used by the regular grid
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class LIB_GEOMETRY_EXPORT Cell
+{
+ public:
+  
+  Cell(Vec3r& orig) {
+    _orig = orig;
+  }
+
+  virtual ~Cell() {}
+
+  inline void addOccluder(Polygon3r* o) {
+    if (o)
+      _occluders.push_back(o);
+  }
+
+  inline const Vec3r& getOrigin() {
+    return _orig;
+  }
+
+  inline OccludersSet& getOccluders() {
+    return _occluders;
+  }
+  
+ private:
+
+  Vec3r		_orig;
+  OccludersSet	_occluders;
+};
+
+
+class GridVisitor{
+public:
+	virtual ~GridVisitor() {}; //soc
+    virtual void discoverCell(Cell *cell) {}
+    virtual void examineOccluder(Polygon3r *occ) {}
+    virtual void finishCell(Cell *cell) {}
+    virtual bool stop() {return false;}
+};
+
+/*! Gathers all the occluders belonging to the cells
+ * traversed by the ray */
+class allOccludersGridVisitor : public GridVisitor{
+public:
+    allOccludersGridVisitor(OccludersSet& occluders)
+        :GridVisitor(), occluders_(occluders){}
+    virtual void examineOccluder(Polygon3r *occ);
+
+    OccludersSet& occluders() {return occluders_;}
+    void clear() {occluders_.clear();}
+
+private:
+    OccludersSet& occluders_;
+};
+
+/*! Finds the first intersection and breaks. The occluder and 
+ * the intersection information are stored and accessible.
+ */
+class firstIntersectionGridVisitor : public GridVisitor {
+
+//soc - changed order to remove warnings
+public:
+    double u_, v_, t_;
+private:
+    Polygon3r *occluder_;
+	Vec3r ray_org_, ray_dir_, cell_size_;
+    Cell * current_cell_;
+
+public:
+      firstIntersectionGridVisitor(const Vec3r& ray_org, const Vec3r& ray_dir, const Vec3r& cell_size) : 
+		 GridVisitor(), u_(0),v_(0),t_(DBL_MAX),
+		 occluder_(0),
+		 ray_org_(ray_org), ray_dir_(ray_dir), cell_size_(cell_size),
+      	 current_cell_(0) {}
+      virtual ~firstIntersectionGridVisitor() {}
+
+    virtual void discoverCell(Cell *cell) {current_cell_=cell;}
+    virtual void examineOccluder(Polygon3r *occ);
+    virtual bool stop();
+
+    Polygon3r * occluder() {return occluder_;}
+};
+
+//
+// Class to define a regular grid used for ray casting computations
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class LIB_GEOMETRY_EXPORT Grid
+{
+public:
+
+  /*! Builds a Grid 
+   *  Must be followed by a call to configure()
+   */
+  Grid() {}
+
+  virtual ~Grid() {
+    clear();
+  }
+
+  /*! clears the grid
+   *  Deletes all the cells, clears the hashtable,
+   *  resets size, size of cell, number of cells.
+   */
+  virtual void clear();
+
+  /*! Sets the different parameters of the grid
+   *    orig
+   *      The grid origin
+   *    size
+   *      The grid's dimensions
+   *    nb
+   *      The number of cells of the grid
+   */
+  virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
+  
+  /*! returns a vector of integer containing the
+   *  coordinates of the cell containing the point
+   *  passed as argument
+   *    p
+   *      The point for which we're looking the cell
+   */
+  inline void getCellCoordinates(const Vec3r& p, Vec3u& res) {
+    int tmp;
+    for (int i = 0; i < 3; i++) {
+      tmp = (int)((p[i] - _orig[i]) / _cell_size[i]);
+      if (tmp < 0)
+	res[i] = 0;
+      else if ((unsigned)tmp >= _cells_nb[i])
+	res[i] = _cells_nb[i] - 1;
+      else
+	res[i] = tmp;
+    }
+  }
+
+  /*! Fills the case corresponding to coord with the cell */
+  virtual void fillCell(const Vec3u& coord, Cell& cell) = 0;
+
+  /*! returns the cell whose coordinates
+   *  are pased as argument
+   */
+  virtual Cell* getCell(const Vec3u& coord) = 0;
+
+  /*! returns the cell containing the point
+   *  passed as argument. If the cell is empty
+   *  (contains no occluder), NULL is returned
+   *    p
+   *      The point for which we're looking the cell
+   */
+  inline Cell* getCell(const Vec3r& p) {    
+    Vec3u coord;
+    getCellCoordinates(p, coord);
+    return getCell(coord);
+  }
+
+  /*! Retrieves the x,y,z coordinates of the origin of the cell whose coordinates (i,j,k)
+   *  is passed as argument
+   *    cell_coord
+   *      i,j,k integer coordinates for the cell
+   *    orig
+   *      x,y,x vector to be filled in with the cell origin's coordinates
+   */
+  inline void getCellOrigin(const Vec3u& cell_coord, Vec3r& orig) {
+    for (unsigned i = 0; i < 3; i++)
+      orig[i] = _orig[i] + cell_coord[i] * _cell_size[i];
+  }
+
+  /*! Retrieves the box corresponding to the cell whose coordinates
+   *  are passed as argument.
+   *    cell_coord
+   *      i,j,k integer coordinates for the cell
+   *    min_out
+   *      The min x,y,x vector of the box. Filled in by the method.
+   *    max_out
+   *      The max x,y,z coordinates of the box. Filled in by the method.
+   */
+  inline void getCellBox(const Vec3u& cell_coord, Vec3r& min_out, Vec3r& max_out) {
+    getCellOrigin(cell_coord, min_out);
+    max_out = min_out + _cell_size;
+  }
+
+  /*! inserts a convex polygon occluder
+   *  This method is quite coarse insofar as it
+   *  adds all cells intersecting the polygon bounding box
+   *    convex_poly
+   *      The list of 3D points constituing a convex polygon
+   */
+  void insertOccluder(Polygon3r * convex_poly);
+
+  /*! Adds an occluder to the list of occluders */
+  void addOccluder(Polygon3r* occluder) {
+    _occluders.push_back(occluder);
+  }
+
+  /*! Casts a ray between a starting point and an ending point
+   *  Returns the list of occluders contained
+   *  in the cells intersected by this ray
+   *  Starts with a call to InitRay.
+   */
+  void castRay(const Vec3r& orig,
+	       const Vec3r& end,
+	       OccludersSet& occluders,
+	       unsigned timestamp);
+
+  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
+   *  Returns the list of occluders contained
+   *  in the cells intersected by this ray
+   *  Starts with a call to InitRay.
+   */
+  void castInfiniteRay(const Vec3r& orig,
+		       const Vec3r& dir,
+		       OccludersSet& occluders,
+		       unsigned timestamp);
+
+  /*! Casts an infinite ray (still finishing at the end of the grid) from a starting point and in a given direction.
+  *  Returns the first intersection (occluder,t,u,v) or null.
+  *  Starts with a call to InitRay.
+  */
+  Polygon3r * castRayToFindFirstIntersection(const Vec3r& orig,
+      const Vec3r& dir,
+      double& t,
+      double& u,
+      double& v,
+      unsigned timestamp);
+
+
+  /*! Init all structures and values for computing
+   *  the cells intersected by this new ray
+   */
+  void initRay (const Vec3r &orig,
+		const Vec3r& end,
+		unsigned timestamp);
+
+  /*! Init all structures and values for computing
+   *  the cells intersected by this infinite ray.
+   * Returns false if the ray doesn't intersect the 
+   * grid.
+   */
+  bool initInfiniteRay (const Vec3r &orig,
+		const Vec3r& dir,
+		unsigned timestamp);
+
+ 
+  /*! Accessors */
+  inline const Vec3r& getOrigin() const {
+    return _orig;
+  }
+  inline Vec3r gridSize() const {
+    return _size;
+  }
+  inline Vec3r getCellSize() const {
+    return _cell_size;
+  }
+
+  void displayDebug() {
+    cerr << "Cells nb     : " << _cells_nb << endl;
+    cerr << "Cell size    : " << _cell_size << endl;
+    cerr << "Origin       : " << _orig << endl;
+    cerr << "Occluders nb : " << _occluders.size() << endl;
+  }
+
+ protected:
+
+  /*! Core of castRay and castInfiniteRay, find occluders
+   *  along the given ray
+   */
+  inline void castRayInternal(GridVisitor& visitor) {
+    Cell* current_cell = NULL;
+    do {
+      current_cell = getCell(_current_cell);
+      if (current_cell){
+          visitor.discoverCell(current_cell);
+          OccludersSet& occluders = current_cell->getOccluders(); // FIXME: I had forgotten the ref &
+          for (OccludersSet::iterator it = occluders.begin();
+              it != occluders.end();
+              it++) {
+                  if ((unsigned)(*it)->userdata2 != _timestamp) {
+                      (*it)->userdata2 = (void*)_timestamp;
+                      visitor.examineOccluder(*it);
+                  }
+              }
+          visitor.finishCell(current_cell);
+      }
+    } while ((!visitor.stop()) && (nextRayCell(_current_cell, _current_cell)));
+  }
+
+ 
+  /*! returns the  cell next to the cell
+   *  passed as argument.
+   */
+  bool nextRayCell(Vec3u& current_cell, Vec3u& next_cell);
+
+  unsigned	_timestamp;
+
+  Vec3u		_cells_nb;  // number of cells for x,y,z axis
+  Vec3r		_cell_size; // cell x,y,z dimensions
+  Vec3r		_size;      // grid x,y,x dimensions
+  Vec3r		_orig;      // grid origin
+
+  Vec3r		_ray_dir;      // direction vector for the ray
+  Vec3u		_current_cell; // The current cell being processed (designated by its 3 coordinates)
+  Vec3r		_pt;           // Points corresponding to the incoming and outgoing intersections
+                               // of one cell with the ray
+  real		_t_end;        // To know when we are at the end of the ray
+  real		_t;
+
+  //OccludersSet _ray_occluders; // Set storing the occluders contained in the cells traversed by a ray
+  OccludersSet _occluders;     // List of all occluders inserted in the grid
+};
+
+#endif // GRID_H
diff --git a/source/blender/freestyle/intern/geometry/HashGrid.cpp b/source/blender/freestyle/intern/geometry/HashGrid.cpp
new file mode 100755
index 00000000000..3cf845d57ef
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/HashGrid.cpp
@@ -0,0 +1,41 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "HashGrid.h"
+
+void HashGrid::clear()
+{
+  if(!_cells.empty()) {
+    for(GridHashTable::iterator it = _cells.begin();
+	it !=_cells.end();
+	it++) {
+      Cell* cell = (*it).second;
+      delete cell;
+    }
+    _cells.clear();
+  }
+
+  Grid::clear();
+}
+
+void HashGrid::configure(const Vec3r& orig, const Vec3r& size, unsigned nb) {
+  Grid::configure(orig, size, nb);
+}
diff --git a/source/blender/freestyle/intern/geometry/HashGrid.h b/source/blender/freestyle/intern/geometry/HashGrid.h
new file mode 100755
index 00000000000..f6605957676
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/HashGrid.h
@@ -0,0 +1,109 @@
+//
+//  Filename         : HashGrid.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a cell grid surrounding the
+//                     bounding box of the scene
+//  Date of creation : 30/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  HASHGRID_H
+# define HASHGRID_H
+
+//# if defined(__GNUC__) && (__GNUC__ >= 3)
+// hash_map is not part of the C++ standard anymore;
+// hash_map.h has been kept though for backward compatibility
+//#  include <hash_map.h>
+//# else
+//#  include <hash_map>
+//# endif
+
+# include "Grid.h"
+# include <map>
+/*! Defines a hash table used for searching the Cells */
+struct GridHasher{
+#define _MUL 950706376UL
+#define _MOD 2147483647UL
+  inline size_t operator() (const Vec3u& p) const 
+  {
+    size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
+    res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
+    return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
+  }
+};
+
+/*! Class to define a regular grid used for ray
+  casting computations */
+
+class LIB_GEOMETRY_EXPORT HashGrid : public Grid
+{
+ public:
+
+  typedef map<Vec3u, Cell*> GridHashTable;
+  
+  HashGrid() : Grid() {}
+
+  virtual ~HashGrid() {
+    clear();
+  }
+
+  /*! clears the grid
+   *  Deletes all the cells, clears the hashtable,
+   *  resets size, size of cell, number of cells.
+   */
+  virtual void clear();
+
+  /*! Sets the different parameters of the grid
+   *    orig
+   *      The grid origin
+   *    size
+   *      The grid's dimensions
+   *    nb
+   *      The number of cells of the grid
+   */
+  virtual void configure(const Vec3r& orig, const Vec3r& size, unsigned nb);
+  
+  /*! returns the cell whose coordinates
+   *  are pased as argument
+   */
+  virtual Cell* getCell(const Vec3u& p) {
+    Cell* found_cell = NULL;
+    
+    GridHashTable::const_iterator found = _cells.find(p);
+    if (found != _cells.end())
+      found_cell = (*found).second;
+    return found_cell;
+  }
+  
+  /*! Fills the case p with the cell iCell */
+  virtual void fillCell(const Vec3u& p, Cell& cell) {
+    _cells[p] = &cell;
+  }
+
+protected:
+
+  GridHashTable _cells;
+};
+
+#endif // HASHGRID_H
diff --git a/source/blender/freestyle/intern/geometry/Noise.cpp b/source/blender/freestyle/intern/geometry/Noise.cpp
new file mode 100755
index 00000000000..396fc3bbb47
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Noise.cpp
@@ -0,0 +1,264 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Noise.h"
+# include <stdlib.h>
+# include <stdio.h>
+# include <math.h>
+#include <time.h>
+
+#define MINX		-1000000
+#define MINY		MINX
+#define MINZ		MINX
+#define SCURVE(a) ((a)*(a)*(3.0-2.0*(a)))
+#define REALSCALE ( 2.0 / 65536.0 )
+#define NREALSCALE ( 2.0 / 4096.0 )
+#define HASH3D(a,b,c) hashTable[hashTable[hashTable[(a) & 0xfff] ^ ((b) & 0xfff)] ^ ((c) & 0xfff)]
+#define HASH(a,b,c) (xtab[(xtab[(xtab[(a) & 0xff] ^ (b)) & 0xff] ^ (c)) & 0xff] & 0xff)
+#define INCRSUM(m,s,x,y,z)	((s)*(RTable[m]*0.5		\
+					+ RTable[m+1]*(x)	\
+					+ RTable[m+2]*(y)	\
+					+ RTable[m+3]*(z)))
+#define MAXSIZE		500
+#define nrand()		((float)rand()/(float)RAND_MAX)
+#define seednrand(x)	srand(x*RAND_MAX)
+
+#define BM 0xff
+
+#define N 0x1000
+#define NP 12   /* 2^N */
+#define NM 0xfff
+
+#define s_curve(t) ( t * t * (3. - 2. * t) )
+
+#define lerp(t, a, b) ( a + t * (b - a) )
+
+#define setup(i,b0,b1,r0,r1)\
+	t = i + N;\
+	b0 = ((int)t) & BM;\
+	b1 = (b0+1) & BM;\
+	r0 = t - (int)t;\
+	r1 = r0 - 1.;
+
+void normalize2(float v[2])
+{
+  float s;
+
+  s = sqrt(v[0] * v[0] + v[1] * v[1]);
+  v[0] = v[0] / s;
+  v[1] = v[1] / s;
+}
+
+void normalize3(float v[3])
+{
+  float s;
+
+  s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  v[0] = v[0] / s;
+  v[1] = v[1] / s;
+  v[2] = v[2] / s;
+}
+
+float Noise::turbulence1(float arg, float freq, float amp, unsigned oct)
+{
+  float t;
+  float vec;
+  
+  for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) 
+    {
+      vec = freq * arg;
+      t += smoothNoise1(vec) * amp;
+    }
+  return t;
+}
+
+float Noise::turbulence2(Vec2f& v, float freq, float amp, unsigned oct)
+{
+  float t;
+  Vec2f vec;
+  
+  for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) 
+    {
+      vec.x() = freq * v.x();
+      vec.y() = freq * v.y();
+      t += smoothNoise2(vec) * amp;
+    }
+  return t;
+}
+
+float Noise::turbulence3(Vec3f& v, float freq, float amp, unsigned oct)
+{
+  float t;
+  Vec3f vec;
+  
+  for (t = 0; oct > 0 && freq > 0; freq *= 2, amp /= 2, --oct) 
+    {
+      vec.x() = freq * v.x();
+      vec.y() = freq * v.y();
+      vec.z() = freq * v.z();
+      t += smoothNoise3(vec) * amp;
+    }
+  return t;
+}
+
+// Noise functions over 1, 2, and 3 dimensions
+
+float Noise::smoothNoise1(float arg)
+{
+  int bx0, bx1;
+  float rx0, rx1, sx, t, u, v, vec;
+
+  vec = arg;
+  setup(vec, bx0,bx1, rx0,rx1);
+
+  sx = s_curve(rx0);
+
+  u = rx0 * g1[ p[ bx0 ] ];
+  v = rx1 * g1[ p[ bx1 ] ];
+
+  return lerp(sx, u, v);
+}
+
+float Noise::smoothNoise2(Vec2f& vec)
+{
+  int bx0, bx1, by0, by1, b00, b10, b01, b11;
+  float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
+  register int i, j;
+
+  setup(vec.x(), bx0,bx1, rx0,rx1);
+  setup(vec.y(), by0,by1, ry0,ry1);
+
+  i = p[ bx0 ];
+  j = p[ bx1 ];
+
+  b00 = p[ i + by0 ];
+  b10 = p[ j + by0 ];
+  b01 = p[ i + by1 ];
+  b11 = p[ j + by1 ];
+
+  sx = s_curve(rx0);
+  sy = s_curve(ry0);
+
+#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
+
+  q = g2[ b00 ] ; u = at2(rx0,ry0);
+  q = g2[ b10 ] ; v = at2(rx1,ry0);
+  a = lerp(sx, u, v);
+
+  q = g2[ b01 ] ; u = at2(rx0,ry1);
+  q = g2[ b11 ] ; v = at2(rx1,ry1);
+  b = lerp(sx, u, v);
+
+  return lerp(sy, a, b);
+}
+
+float Noise::smoothNoise3(Vec3f& vec)
+{
+  int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
+  float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
+  register int i, j;
+
+  setup(vec.x(), bx0,bx1, rx0,rx1);
+  setup(vec.y(), by0,by1, ry0,ry1);
+  setup(vec.z(), bz0,bz1, rz0,rz1);
+
+  i = p[ bx0 ];
+  j = p[ bx1 ];
+
+  b00 = p[ i + by0 ];
+  b10 = p[ j + by0 ];
+  b01 = p[ i + by1 ];
+  b11 = p[ j + by1 ];
+
+  t  = s_curve(rx0);
+  sy = s_curve(ry0);
+  sz = s_curve(rz0);
+
+#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
+
+  q = g3[ b00 + bz0 ] ;
+  u = at3(rx0,ry0,rz0);
+  q = g3[ b10 + bz0 ] ;
+  v = at3(rx1,ry0,rz0);
+  a = lerp(t, u, v);
+
+  q = g3[ b01 + bz0 ] ;
+  u = at3(rx0,ry1,rz0);
+  q = g3[ b11 + bz0 ] ;
+  v = at3(rx1,ry1,rz0);
+  b = lerp(t, u, v);
+
+  c = lerp(sy, a, b);
+
+  q = g3[ b00 + bz1 ] ;
+  u = at3(rx0,ry0,rz1);
+  q = g3[ b10 + bz1 ] ;
+  v = at3(rx1,ry0,rz1);
+  a = lerp(t, u, v);
+
+  q = g3[ b01 + bz1 ] ;
+  u = at3(rx0,ry1,rz1);
+  q = g3[ b11 + bz1 ] ;
+  v = at3(rx1,ry1,rz1);
+  b = lerp(t, u, v);
+
+  d = lerp(sy, a, b);
+
+  return lerp(sz, c, d);
+}
+
+Noise::Noise()
+{
+  int i, j, k;
+  
+  seednrand(time(NULL));
+  for (i = 0 ; i < _Noise_B_ ; i++) 
+    {
+      p[i] = i;
+
+      g1[i] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
+
+      for (j = 0 ; j < 2 ; j++)
+	g2[i][j] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
+      normalize2(g2[i]);
+
+      for (j = 0 ; j < 3 ; j++)
+	g3[i][j] = (float)((rand() % (_Noise_B_ + _Noise_B_)) - _Noise_B_) / _Noise_B_;
+      normalize3(g3[i]);
+    }
+
+  while (--i) 
+    {
+      k = p[i];
+      p[i] = p[j = rand() % _Noise_B_];
+      p[j] = k;
+    }
+
+  for (i = 0 ; i < _Noise_B_ + 2 ; i++) 
+    {
+      p[_Noise_B_ + i] = p[i];
+      g1[_Noise_B_ + i] = g1[i];
+      for (j = 0 ; j < 2 ; j++)
+	g2[_Noise_B_ + i][j] = g2[i][j];
+      for (j = 0 ; j < 3 ; j++)
+	g3[_Noise_B_ + i][j] = g3[i][j];
+    }
+}
diff --git a/source/blender/freestyle/intern/geometry/Noise.h b/source/blender/freestyle/intern/geometry/Noise.h
new file mode 100755
index 00000000000..00cebbb451e
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Noise.h
@@ -0,0 +1,77 @@
+//
+//  Filename         : Noise.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Class to define Perlin noise
+//  Date of creation : 12/01/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef NOISE_H
+# define NOISE_H
+
+
+# include "../system/FreestyleConfig.h"
+# include "Geom.h"
+
+#define _Noise_B_ 0x100
+
+using namespace Geometry;
+using namespace std;
+
+/*! Class to provide Perlin Noise functionalities */
+class LIB_GEOMETRY_EXPORT Noise
+{
+ public:
+
+  /*! Builds a Noise object */
+  Noise();
+  /*! Destructor */
+  ~Noise() {}
+
+  /*! Returns a noise value for a 1D element */
+  float turbulence1(float arg, float freq, float amp, unsigned oct = 4);
+
+  /*! Returns a noise value for a 2D element */
+  float turbulence2(Vec2f& v, float freq, float amp, unsigned oct = 4);
+
+  /*! Returns a noise value for a 3D element */
+  float turbulence3(Vec3f& v, float freq, float amp, unsigned oct = 4);
+
+  /*! Returns a smooth noise value for a 1D element */
+  float smoothNoise1(float arg);
+  /*! Returns a smooth noise value for a 2D element */
+  float smoothNoise2(Vec2f& vec);
+  /*! Returns a smooth noise value for a 3D element */
+  float smoothNoise3(Vec3f& vec);
+
+ private:
+
+  int p[ _Noise_B_ + _Noise_B_ + 2];
+  float g3[ _Noise_B_ + _Noise_B_ + 2][3];
+  float g2[ _Noise_B_ + _Noise_B_ + 2][2];
+  float g1[ _Noise_B_ + _Noise_B_ + 2];
+  int start;
+};
+
+#endif // NOISE_H
diff --git a/source/blender/freestyle/intern/geometry/Polygon.h b/source/blender/freestyle/intern/geometry/Polygon.h
new file mode 100755
index 00000000000..f9c4c78d424
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Polygon.h
@@ -0,0 +1,215 @@
+//
+//  Filename         : Polygon.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a polygon
+//  Date of creation : 30/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  POLYGON_H
+# define POLYGON_H
+
+# include <vector>
+# include "Geom.h"
+# include "GeomUtils.h"
+
+using namespace std;
+
+namespace Geometry {
+
+template <class Point>
+class Polygon
+{
+ public:
+
+  inline Polygon() {
+    _id = 0;
+    userdata = 0;
+    userdata2 = 0;
+  }
+
+  inline Polygon(const vector<Point>& vertices) {
+    _vertices = vertices;
+    computeBBox();
+    _id = 0;
+    userdata = 0;
+    userdata2 = 0;
+  }
+
+  inline Polygon(const Polygon<Point>& poly) {
+    Point p;
+    for(typename vector<Point>::const_iterator it = poly.getVertices().begin();
+	it != poly.getVertices().end();
+	it++) {
+      p = *it;
+      _vertices.push_back(p);
+    }
+
+    _id = poly.getId();
+    poly.getBBox(_min, _max);
+    userdata = 0;
+    userdata2 = 0;
+  }
+  
+  virtual ~Polygon() {}
+
+  //
+  // Accessors
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  inline const vector<Point>& getVertices() const {
+    return _vertices;
+  }
+
+  inline void getBBox(Point& min, Point& max) const {
+    min = _min;
+    max = _max;
+  }
+
+  inline Point& getBBoxCenter()
+  {
+    Point result;
+    result = (_min + _max) / 2;
+    return result;
+  }
+
+  inline Point& getCenter() {
+    Point result;
+    for (typename vector<Point>::iterator it = _vertices.begin();
+	 it != _vertices.end();
+	 it++)
+      result += *it;
+    result /= _vertices.size();
+    return result;
+  }
+
+  inline unsigned getId() const {
+    return _id;
+  }
+
+  //
+  // Modifiers
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  inline void setVertices(const vector<Point>& vertices) {
+    _vertices.clear();
+    Point p;
+    for (typename vector<Point>::const_iterator it = vertices.begin();
+	 it != vertices.end();
+	 it++) {
+      p = *it;
+      _vertices.push_back(p);
+    }
+    computeBBox();
+  }
+
+  inline void setId(unsigned id) {
+    _id = id;
+  }
+
+  //
+  // Other methods
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  inline void computeBBox() {
+    if(_vertices.empty())
+      return;
+    
+    _max = _vertices[0];
+    _min = _vertices[0];
+
+    for(typename vector<Point>::iterator it = _vertices.begin();
+	it != _vertices.end();
+        it++) {
+      for(unsigned i = 0; i < Point::dim(); i++) {
+	if((*it)[i] > _max[i])
+	  _max[i] = (*it)[i];
+	if((*it)[i] < _min[i])
+	  _min[i] = (*it)[i];
+      }
+    }
+  }
+  
+  // FIXME Is it possible to get rid of userdatas ?
+  void* userdata;
+  void* userdata2; // Used during ray casting
+  
+ protected:
+  
+  vector<Point>	_vertices;
+  Point		_min;
+  Point		_max;
+  unsigned	_id;
+};
+
+
+//
+// Polygon3r class
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class Polygon3r : public Polygon<Vec3r>
+{
+ public:
+
+  inline Polygon3r() : Polygon<Vec3r>() {}
+
+  inline Polygon3r(const vector<Vec3r>& vertices,
+		   const Vec3r& normal) : Polygon<Vec3r>(vertices) {
+    setNormal(normal);
+  }
+
+  inline Polygon3r(const Polygon3r& poly) : Polygon<Vec3r>(poly) {}
+  
+  virtual ~Polygon3r() {}
+
+  void setNormal(const Vec3r& normal) {
+    _normal = normal;
+  }
+
+  Vec3r getNormal() const {
+    return _normal;
+  }
+
+  /*! Check whether the Polygon intersects with the ray or not */
+  inline bool rayIntersect(Vec3r& orig, Vec3r& dir,
+			   real& t, real& u, real& v, real epsilon = M_EPSILON) {
+    //    if (_vertices.size() < 3)
+    //      return false;
+    return GeomUtils::intersectRayTriangle(orig, dir,
+					   _vertices[0], _vertices[1], _vertices[2],
+					   t, u, v, epsilon);
+  }
+
+ private:
+
+  Vec3r	_normal;
+};
+
+} // end of namespace Geometry
+
+#endif // POLYGON_H
diff --git a/source/blender/freestyle/intern/geometry/SweepLine.h b/source/blender/freestyle/intern/geometry/SweepLine.h
new file mode 100755
index 00000000000..e3fb4ad8c0c
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/SweepLine.h
@@ -0,0 +1,334 @@
+//
+//  Filename         : SweepLine.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a Sweep Line
+//  Date of creation : 29/08/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SWEEPLINE_H
+# define SWEEPLINE_H
+
+# include <list>
+# include <vector>
+
+/*! Class to define the intersection berween two segments*/
+template<class Edge>
+class Intersection
+{
+public:
+
+  template<class EdgeClass>
+  Intersection(EdgeClass* eA, real ta, EdgeClass* eB, real tb)
+  {
+    EdgeA = eA;
+    EdgeB = eB;
+    tA = ta;
+    tB = tb;
+    userdata = 0;
+  }
+
+  Intersection(const Intersection& iBrother)
+  {
+    EdgeA = iBrother.EdgeA;
+    EdgeB = iBrother.EdgeB;
+    tA = iBrother.tA;
+    tB = iBrother.tB;
+    userdata = 0;
+  }
+
+  /*! returns the parameter giving the 
+   *  intersection, for the edge iEdge 
+   */
+  real getParameter(Edge *iEdge) 
+  {
+    if(iEdge == EdgeA)
+      return tA;
+    if(iEdge == EdgeB)
+      return tB;
+    return 0;
+  }
+
+public:
+  void * userdata; // FIXME
+
+  Edge *EdgeA; // first segment
+  Edge *EdgeB; // second segment
+  real tA; // parameter defining the intersection point with respect to the segment EdgeA.
+  real tB; // parameter defining the intersection point with respect to the segment EdgeB.
+};
+
+
+
+
+
+
+
+
+template<class T, class Point>
+class Segment
+{
+  public:
+    Segment()
+    {
+    }
+    Segment(T& s, const Point& iA, const Point& iB) 
+    {
+      _edge = s;
+      if(iA < iB)
+      {
+        A = iA;
+        B = iB;
+        _order = true;
+      }
+      else
+      {
+        A = iB;
+        B = iA;
+        _order = false;
+      }
+    }
+
+    Segment(Segment<T,Point>& iBrother)
+    {
+      _edge = iBrother.edge();
+      A = iBrother.A;
+      B = iBrother.B;
+      _Intersections = iBrother._Intersections;
+      _order = iBrother._order;
+    }
+
+    Segment(const Segment<T,Point>& iBrother)
+    {
+      _edge = iBrother._edge;
+      A = iBrother.A;
+      B = iBrother.B;
+      _Intersections = iBrother._Intersections;
+      _order = iBrother._order;
+    }
+
+    ~Segment() {
+      _Intersections.clear();
+    }
+
+    inline Point operator[](const unsigned short int& i) const
+    {
+      return i%2==0 ? A : B;
+    }
+
+    inline bool operator==(const Segment<T,Point>& iBrother)
+    {
+      if(_edge == iBrother._edge)
+        return true;
+
+      return false;
+    }
+  
+    /* Adds an intersection for this segment */
+    inline void AddIntersection(Intersection<Segment<T,Point> > *i) {_Intersections.push_back(i);}
+
+    /*! Checks for a common vertex with another edge */
+    inline bool CommonVertex(const Segment<T,Point>& S, Point& CP)
+    {
+      if((A == S[0]) || (A == S[1]))
+      {
+        CP = A;
+        return true;
+      }
+      if((B == S[0]) || (B == S[1]))
+      {
+        CP = B;
+        return true;
+      }
+
+      return false;
+    }
+
+    inline vector<Intersection<Segment<T,Point> >*>& intersections() {return _Intersections;}
+    inline bool order() {return _order;}
+    inline T& edge() {return _edge;}
+
+  private:
+    T _edge;
+    Point A;
+    Point B;
+    std::vector<Intersection<Segment<T,Point> >*> _Intersections; // list of intersections parameters
+    bool _order; // true if A and B are in the same order than _edge.A and _edge.B. false otherwise.
+};
+
+/*! defines a binary function that can be overload 
+ *  by the user to specify at each condition 
+ *  the intersection between 2 edges must be computed
+ */
+template<class T1, class T2>
+struct binary_rule 
+{
+  binary_rule() {}
+  template<class T3,class T4>
+  binary_rule(const binary_rule<T3,T4>& brother) {}
+  virtual ~binary_rule() {}
+
+  virtual bool operator()(T1&, T2&)
+  {
+    return true;
+  }
+};
+
+
+template<class T,class Point>
+class SweepLine 
+{
+public:
+
+  SweepLine() {}
+  ~SweepLine() 
+  {
+    for(typename vector<Intersection<Segment<T,Point> >*>::iterator i=_Intersections.begin(),iend=_Intersections.end();
+    i!=iend;
+    i++)
+    {
+      delete (*i);
+    }
+    _Intersections.clear();
+
+    for(typename vector<Segment<T,Point>* >::iterator ie=_IntersectedEdges.begin(),ieend=_IntersectedEdges.end();
+    ie!=ieend;
+    ie++)
+    {
+      delete (*ie);
+    }
+    _IntersectedEdges.clear();
+
+    _set.clear();
+  }
+
+  
+  inline void process(Point& p, 
+                      vector<Segment<T,Point>*>& segments, 
+                      binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule
+                      //binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = binary_rule<Segment<T,Point>,Segment<T,Point> >()
+                      ) 
+  {
+    // first we remove the segments that need to be removed and then 
+    // we add the segments to add
+    vector<Segment<T,Point>*> toadd;
+    typename vector<Segment<T,Point>*>::iterator s, send;
+    for(s=segments.begin(), send=segments.end();
+    s!=send;
+    s++)
+    {
+       if(p == (*(*s))[0])
+        toadd.push_back((*s));
+      else
+        remove((*s));
+    }
+    for(s=toadd.begin(), send=toadd.end();
+    s!=send;
+    s++)
+    {
+      add((*s), binrule);
+    }
+  }
+  
+  inline void add(Segment<T,Point>* S,
+                  binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule
+                  //binary_rule<Segment<T,Point>,Segment<T,Point> >& binrule = binary_rule<Segment<T,Point>, Segment<T,Point> >()
+                  )
+  {
+    real t,u;
+    Point CP;
+    Vec2r v0, v1, v2, v3;
+    if(true == S->order())
+    {
+      v0[0] = ((*S)[0])[0];
+      v0[1] = ((*S)[0])[1];
+      v1[0] = ((*S)[1])[0];
+      v1[1] = ((*S)[1])[1];
+    }
+    else
+    {
+      v1[0] = ((*S)[0])[0];
+      v1[1] = ((*S)[0])[1];
+      v0[0] = ((*S)[1])[0];
+      v0[1] = ((*S)[1])[1];
+    }
+    for(typename std::list<Segment<T,Point>* >::iterator s=_set.begin(), send=_set.end();
+    s!=send;
+    s++)
+    {
+      Segment<T,Point>* currentS = (*s);
+      if(true != binrule(*S, *currentS))
+        continue;
+
+      if(true == currentS->order())
+      {
+        v2[0] = ((*currentS)[0])[0];
+	v2[1] = ((*currentS)[0])[1];
+        v3[0] = ((*currentS)[1])[0];
+	v3[1] = ((*currentS)[1])[1];
+      }
+      else
+      {
+        v3[0] = ((*currentS)[0])[0];
+	v3[1] = ((*currentS)[0])[1];
+        v2[0] = ((*currentS)[1])[0];
+	v2[1] = ((*currentS)[1])[1];
+      }
+      if(S->CommonVertex(*currentS, CP))
+        continue; // the two edges have a common vertex->no need to check
+      
+      if(GeomUtils::intersect2dSeg2dSegParametric(v0, v1, v2, v3, t, u))
+      {
+        // create the intersection
+        Intersection<Segment<T,Point> > * inter = new Intersection<Segment<T,Point> >(S,t,currentS,u);
+        // add it to the intersections list
+        _Intersections.push_back(inter);
+        // add this intersection to the first edge intersections list
+        S->AddIntersection(inter);
+        // add this intersection to the second edge intersections list
+        currentS->AddIntersection(inter);        
+      }
+    }
+    // add the added segment to the list of active segments
+    _set.push_back(S);
+  }
+  
+  inline void remove(Segment<T,Point>* s) 
+  {
+    if(s->intersections().size() > 0)
+      _IntersectedEdges.push_back(s);
+    _set.remove(s);
+  }
+
+  vector<Segment<T,Point>* >& intersectedEdges() {return _IntersectedEdges;}
+  vector<Intersection<Segment<T,Point> >*>& intersections() {return _Intersections;}
+  
+
+private:
+  std::list<Segment<T,Point>* > _set; // set of active edges for a given position of the sweep line
+  std::vector<Segment<T,Point>* > _IntersectedEdges; // the list of intersected edges
+  std::vector<Intersection<Segment<T,Point> >*> _Intersections; // the list of all intersections.
+};
+
+#endif // SWEEPLINE_H
diff --git a/source/blender/freestyle/intern/geometry/VecMat.h b/source/blender/freestyle/intern/geometry/VecMat.h
new file mode 100755
index 00000000000..9bbec3b1349
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/VecMat.h
@@ -0,0 +1,899 @@
+//
+//  Filename         : VecMat.h
+//  Author(s)        : Sylvain Paris
+//                     Emmanuel Turquin
+//                     Stephane Grabli 
+//  Purpose          : Vectors and Matrices definition and manipulation
+//  Date of creation : 12/06/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VECMAT_H
+# define VECMAT_H
+
+# include <math.h>
+# include <vector>
+# include <iostream>
+
+namespace VecMat {
+
+  namespace Internal {
+
+    template <bool B>
+    struct is_false {};
+
+    template <>
+    struct is_false<false> {
+      static inline void ensure() {}
+    };
+
+  } // end of namespace Internal
+
+  //
+  //  Vector class
+  //    - T: value type
+  //    - N: dimension
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  template <class T, unsigned N>
+  class Vec
+  {
+  public:
+
+    typedef T value_type;
+    
+    // constructors
+
+    inline Vec() {
+      for (unsigned i = 0; i < N; i++)
+	this->_coord[i] = 0;
+    }
+
+    ~Vec() {
+      Internal::is_false<(N == 0)>::ensure();
+    }
+
+    template <class U>
+    explicit inline Vec(const U tab[N]) {
+      for (unsigned i = 0; i < N; i++)
+	this->_coord[i] = (T)tab[i];
+    }
+
+    template <class U>
+    explicit inline Vec(const std::vector<U>& tab) {
+      for (unsigned i = 0; i < N; i++)
+	this->_coord[i] = (T)tab[i];
+    }
+
+    template <class U>
+    explicit inline Vec(const Vec<U, N>& v) {
+      for (unsigned i = 0; i < N; i++)
+        this->_coord[i] = (T)v[i];
+    }
+
+    // accessors
+
+    inline value_type  operator[](const unsigned i) const {
+      return this->_coord[i];
+    }
+
+    inline value_type& operator[](const unsigned i) {
+      return this->_coord[i];
+    }
+
+    static inline unsigned dim() {
+      return N;
+    }
+    
+    // various useful methods
+
+    inline value_type norm() const {
+      return (T)sqrt((float)squareNorm());
+    }
+
+    inline value_type squareNorm() const {
+      return (*this) * (*this);
+    }
+
+    inline Vec<T, N>& normalize() {
+      value_type n = norm();
+      for (unsigned i = 0; i < N; i++)
+	this->_coord[i] /= n;
+      return *this;
+    }
+
+    inline Vec<T, N>& normalizeSafe() {
+      value_type n = norm();
+      if (n)
+	for (unsigned i=0; i < N; i++)
+	  this->_coord[i] /= n;
+      return *this;
+    }
+
+    // classical operators
+    inline Vec<T, N> operator+(const Vec<T, N>& v) const{
+    Vec<T, N> res(v);
+    res += *this;
+    return res;
+    } 
+
+    inline Vec<T, N> operator-(const Vec<T,N>& v) const{
+    Vec<T, N> res(*this);
+    res -= v;
+    return res;
+    } 
+
+    inline Vec<T, N> operator*(const typename Vec<T,N>::value_type r) const{
+    Vec<T, N> res(*this);
+    res *= r;
+    return res;
+    } 
+
+    inline Vec<T, N> operator/(const typename Vec<T,N>::value_type r) const{
+    Vec<T, N> res(*this);
+    if (r)
+      res /= r;
+    return res;
+    } 
+
+    // dot product
+    inline value_type operator*(const Vec<T, N>& v) const{
+    value_type sum = 0;
+    for (unsigned i = 0; i < N; i++)
+      sum += (*this)[i] * v[i];
+    return sum;
+    } 
+    
+    template <class U>
+    inline Vec<T, N>& operator=(const Vec<U, N>& v) {
+      if (this != &v)
+	for (unsigned i = 0; i < N; i++)
+	  this->_coord[i] = (T)v[i];
+      return *this;
+    }
+
+    template <class U>
+    inline Vec<T, N>& operator+=(const Vec<U, N>& v) {
+      for (unsigned i = 0 ; i < N; i++)
+	this->_coord[i] += (T)v[i];
+      return *this;
+    }
+
+    template <class U>
+    inline Vec<T, N>& operator-=(const Vec<U, N>& v) {
+      for (unsigned i = 0 ; i < N; i++)
+	this->_coord[i] -= (T)v[i];
+      return *this;
+    }
+
+    template <class U>
+    inline Vec<T, N>& operator*=(const U r) {
+      for (unsigned i = 0 ; i < N; i++)
+	this->_coord[i] *= r;
+      return *this;
+    }
+
+    template <class U>
+    inline Vec<T, N>& operator/=(const U r) {
+      if (r)
+	for (unsigned i = 0 ; i < N; i++)
+	  this->_coord[i] /= r;
+      return *this;
+    }
+
+
+    inline bool operator==(const Vec<T, N>& v) const {
+      for(unsigned i = 0; i < N; i++)
+	if (this->_coord[i] != v[i])
+	  return false;
+      return true;
+    }
+
+    inline bool operator!=(const Vec<T, N>& v) const {
+      for(unsigned i = 0; i < N; i++)
+	if (this->_coord[i] != v[i])
+	  return true;
+      return false;
+    }
+
+    inline bool operator<(const Vec<T, N>& v) const {
+      for (unsigned i = 0; i<N; i++) {
+	if (this->_coord[i] < v[i])
+	  return true;
+	if (this->_coord[i] > v[i])
+	  return false;
+	if (this->_coord[i] == v[i])
+	  continue;
+      }
+      return false;  
+    }
+
+    inline bool operator>(const Vec<T, N>& v) const {
+      for (unsigned i=0; i<N; i++) {
+	if(this->_coord[i] > v[i])
+	  return true;
+	if(this->_coord[i] < v[i])
+	  return false;
+	if(this->_coord[i] == v[i])
+	  continue;
+      }
+      return false;  
+    }
+
+  protected:
+
+    value_type _coord[N];
+    enum {
+      _dim = N,
+    };
+  };
+
+
+  //
+  //  Vec2 class (2D Vector)
+  //    - T: value type
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  template <class T>
+  class Vec2 : public Vec<T, 2>
+  {
+  public:
+
+    typedef typename Vec<T, 2>::value_type value_type;
+
+    inline Vec2() : Vec<T, 2>() {}
+
+    template <class U>
+    explicit inline Vec2(const U tab[2]) : Vec<T, 2>(tab) {}
+
+    template <class U>
+    explicit inline Vec2(const std::vector<U>& tab) : Vec<T, 2>(tab) {}
+
+    template <class U>
+    inline Vec2(const Vec<U, 2>& v) : Vec<T, 2>(v) {}
+
+    inline Vec2(const value_type x,
+		const value_type y = 0) : Vec<T, 2>() {
+      this->_coord[0] = (T)x;
+      this->_coord[1] = (T)y;
+    }
+    
+    inline value_type x() const {
+      return this->_coord[0];
+    }
+
+    inline value_type& x() {
+      return this->_coord[0];
+    }
+
+    inline value_type y() const {
+      return this->_coord[1];
+    }
+
+    inline value_type& y() {
+      return this->_coord[1];
+    }
+
+    inline void setX(const value_type v) {
+      this->_coord[0] = v;
+    }
+
+    inline void setY(const value_type v) {
+      this->_coord[1] = v;
+    }
+
+    // FIXME: hack swig -- no choice
+    inline Vec2<T> operator+(const Vec2<T>& v) const{
+    Vec2<T> res(v);
+    res += *this;
+    return res;
+    } 
+
+    inline Vec2<T> operator-(const Vec2<T>& v) const{
+    Vec2<T> res(*this);
+    res -= v;
+    return res;
+    } 
+
+    inline Vec2<T> operator*(const value_type r) const{
+    Vec2<T> res(*this);
+    res *= r;
+    return res;
+    } 
+
+    inline Vec2<T> operator/(const value_type r) const{
+    Vec2<T> res(*this);
+    if (r)
+      res /= r;
+    return res;
+    } 
+
+    // dot product
+    inline value_type operator*(const Vec2<T>& v) const{
+    value_type sum = 0;
+    for (unsigned i = 0; i < 2; i++)
+      sum += (*this)[i] * v[i];
+    return sum;
+    } 
+  };
+
+
+  //
+  //  HVec3 class (3D Vector in homogeneous coordinates)
+  //    - T: value type
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  template <class T>
+  class HVec3 : public Vec<T, 4>
+  {
+  public:
+
+    typedef typename Vec<T, 4>::value_type value_type;
+
+    inline HVec3() : Vec<T, 4>() {}
+
+    template <class U>
+    explicit inline HVec3(const U tab[4]) : Vec<T, 4>(tab) {}
+
+    template <class U>
+    explicit inline HVec3(const std::vector<U>& tab) : Vec<T, 4>(tab) {}
+
+    template<class U>
+    inline HVec3(const Vec<U, 4>& v) : Vec<T, 4>(v) {}
+  
+    inline HVec3(const value_type sx,
+		 const value_type sy = 0,
+		 const value_type sz = 0,
+		 const value_type s = 1) {
+      this->_coord[0] = sx;
+      this->_coord[1] = sy;
+      this->_coord[2] = sz;
+      this->_coord[3] = s;
+    }
+    
+    template <class U>
+    inline HVec3(const Vec<U, 3>& sv,
+		 const U s = 1) {
+      this->_coord[0] = (T)sv[0];
+      this->_coord[1] = (T)sv[1];
+      this->_coord[2] = (T)sv[2];
+      this->_coord[3] = (T)s;
+    }
+    
+    inline value_type sx() const {
+      return this->_coord[0];
+    }
+
+    inline value_type& sx() {
+      return this->_coord[0];
+    }
+
+    inline value_type sy() const {
+      return this->_coord[1];
+    }
+
+    inline value_type& sy() {
+      return this->_coord[1];
+    }
+
+    inline value_type sz() const {
+      return this->_coord[2];
+    }
+
+    inline value_type& sz() {
+      return this->_coord[2];
+    }
+
+    inline value_type s() const {
+      return this->_coord[3];
+    }
+
+    inline value_type& s() {
+      return this->_coord[3];
+    }
+
+    // Acces to non-homogeneous coordinates in 3D
+
+    inline value_type x() const {
+      return this->_coord[0] / this->_coord[3];
+    }
+
+    inline value_type y() const {
+      return this->_coord[1] / this->_coord[3];
+    }
+
+    inline value_type z() const {
+      return this->_coord[2] / this->_coord[3];
+    }
+  };
+
+
+  //
+  //  Vec3 class (3D Vec)
+  //    - T: value type
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  template <class T>
+  class Vec3 : public Vec<T, 3>
+  {
+  public:
+    
+    typedef typename Vec<T, 3>::value_type value_type;
+
+    inline Vec3() : Vec<T, 3>() {}
+
+    template <class U>
+    explicit inline Vec3(const U tab[3]) : Vec<T, 3>(tab) {}
+
+    template <class U>
+    explicit inline Vec3(const std::vector<U>& tab) : Vec<T, 3>(tab) {}
+
+    template<class U>
+    inline Vec3(const Vec<U, 3>& v) : Vec<T, 3>(v) {}
+  
+    template<class U>
+      inline Vec3(const HVec3<U>& v) {
+      this->_coord[0] = (T)v.x();
+      this->_coord[1] = (T)v.y();
+      this->_coord[2] = (T)v.z();
+    }
+
+    inline Vec3(const value_type x,
+		const value_type y = 0,
+		const value_type z = 0) : Vec<T, 3>() {
+      this->_coord[0] = x;
+      this->_coord[1] = y;
+      this->_coord[2] = z;
+    }
+    
+    inline value_type x() const {
+      return this->_coord[0];
+    }
+
+    inline value_type& x() {
+      return this->_coord[0];
+    }
+
+    inline value_type y() const {
+      return this->_coord[1];
+    }
+
+    inline value_type& y() {
+      return this->_coord[1];
+    }
+
+    inline value_type z() const {
+      return this->_coord[2];
+    }
+
+    inline value_type& z() {
+      return this->_coord[2];
+    }
+
+    inline void setX(const value_type v) {
+      this->_coord[0] = v;
+    }
+
+    inline void setY(const value_type v) {
+      this->_coord[1] = v;
+    }
+
+    inline void setZ(const value_type v) {
+      this->_coord[2] = v;
+    }
+
+    // classical operators
+    // FIXME: hack swig -- no choice
+    inline Vec3<T> operator+(const Vec3<T>& v) const{
+    Vec3<T> res(v);
+    res += *this;
+    return res;
+    } 
+
+    inline Vec3<T> operator-(const Vec3<T>& v) const{
+    Vec3<T> res(*this);
+    res -= v;
+    return res;
+    } 
+
+    inline Vec3<T> operator*(const value_type r) const{
+    Vec3<T> res(*this);
+    res *= r;
+    return res;
+    } 
+
+    inline Vec3<T> operator/(const value_type r) const{
+    Vec3<T> res(*this);
+    if (r)
+      res /= r;
+    return res;
+    } 
+
+    // dot product
+    inline value_type operator*(const Vec3<T>& v) const{
+    value_type sum = 0;
+    for (unsigned i = 0; i < 3; i++)
+      sum += (*this)[i] * v[i];
+    return sum;
+    } 
+
+    // cross product for 3D Vectors
+    // FIXME: hack swig -- no choice
+    inline Vec3<T> operator^(const Vec3<T>& v) const{
+    Vec3<T> res((*this)[1] * v[2] - (*this)[2] * v[1],
+		(*this)[2] * v[0] - (*this)[0] * v[2],
+		(*this)[0] * v[1] - (*this)[1] * v[0]);
+    return res;
+    } 
+
+    // cross product for 3D Vectors
+    template <typename U>
+    inline Vec3<T> operator^(const Vec<U, 3>& v) const{
+    Vec3<T> res((*this)[1] * v[2] - (*this)[2] * v[1],
+		(*this)[2] * v[0] - (*this)[0] * v[2],
+		(*this)[0] * v[1] - (*this)[1] * v[0]);
+    return res;
+    } 
+  };
+
+
+  //
+  //  Matrix class
+  //    - T: value type
+  //    - M: rows
+  //    - N: cols
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  
+  // Dirty, but icc under Windows needs this
+# define _SIZE (M * N)
+
+  template <class T, unsigned M, unsigned N>
+  class Matrix
+  {
+  public:
+
+    typedef T value_type;
+    
+    inline Matrix() {
+      for (unsigned i = 0; i < _SIZE; i++)
+	this->_coord[i] = 0;
+    }
+
+    ~Matrix() {
+      Internal::is_false<(M == 0)>::ensure();
+      Internal::is_false<(N == 0)>::ensure();
+    }
+
+    template <class U>
+    explicit inline Matrix(const U tab[_SIZE]) {
+      for (unsigned i = 0; i < _SIZE; i++)
+	this->_coord[i] = tab[i];
+    }
+
+    template <class U>
+    explicit inline Matrix(const std::vector<U>& tab) {
+      for (unsigned i = 0; i < _SIZE; i++)
+	this->_coord[i] = tab[i];
+    }
+
+    template <class U>
+    inline Matrix(const Matrix<U, M, N>& m) {
+      for (unsigned i = 0; i < M; i++)
+	for (unsigned j = 0; j < N; j++)
+	  this->_coord[i * N + j] = (T)m(i, j);
+    }
+
+    inline value_type operator()(const unsigned i, const unsigned j) const {
+      return this->_coord[i * N + j];
+    }
+
+    inline value_type& operator()(const unsigned i, const unsigned j) {
+      return this->_coord[i * N + j];
+    }
+
+    static inline unsigned rows() {
+      return M;
+    }
+
+    static inline unsigned cols() {
+      return N;
+    }
+
+    inline Matrix<T, M, N>& transpose() const {
+      Matrix<T, N, M> res;
+      for (unsigned i = 0; i < M; i++)
+	for (unsigned j = 0; j < N; j++)
+	  res(j,i) = this->_coord[i * N + j];
+      return res;
+    }
+
+    template <class U>
+    inline Matrix<T, M, N>& operator=(const Matrix<U, M, N>& m) {
+      if (this != &m)
+	for (unsigned i = 0; i < M; i++)
+	  for (unsigned j = 0; j < N; j++)
+	    this->_coord[i * N + j] = (T)m(i, j);
+      return *this;
+    }
+
+    template <class U>
+    inline Matrix<T, M, N>& operator+=(const Matrix<U, M, N>& m) {
+      for (unsigned i = 0; i < M; i++)
+	for (unsigned j = 0; j < N; j++)
+	  this->_coord[i * N + j] += (T)m(i, j);
+      return *this;
+    }
+
+    template <class U>
+    inline Matrix<T, M, N>& operator-=(const Matrix<U, M, N>& m) {
+      for (unsigned i = 0; i < M; i++)
+	for (unsigned j = 0; j < N; j++)
+	  this->_coord[i * N + j] -= (T)m(i, j);
+      return *this;
+    }
+
+    template <class U>
+    inline Matrix<T, M, N>& operator*=(const U lambda) {
+      for (unsigned i = 0; i < M; i++)
+	for (unsigned j = 0; j < N; j++)
+	  this->_coord[i * N + j] *= lambda;
+      return *this;
+    }
+
+    template <class U>
+    inline Matrix<T, M, N>& operator/=(const U lambda) {
+      if (lambda)
+	for (unsigned i = 0; i < M; i++)
+	  for (unsigned j = 0; j < N; j++)
+	    this->_coord[i * N + j] /= lambda;
+      return *this;
+    }
+
+  protected:
+
+    value_type _coord[_SIZE];
+  };
+
+
+  //
+  //  SquareMatrix class
+  //    - T: value type
+  //    - N: rows & cols
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  // Dirty, but icc under Windows needs this
+# define __SIZE (N * N)
+
+  template <class T, unsigned N>
+  class SquareMatrix : public Matrix<T, N, N>
+  {
+  public:
+
+    typedef T value_type;
+  
+    inline SquareMatrix() : Matrix<T, N, N>() {}
+
+    template <class U>
+    explicit inline SquareMatrix(const U tab[__SIZE]) : Matrix<T, N, N>(tab) {}
+
+    template <class U>
+    explicit inline SquareMatrix(const std::vector<U>& tab) : Matrix<T, N, N>(tab) {}
+
+    template <class U>
+    inline SquareMatrix(const Matrix<U, N, N>& m) : Matrix<T, N, N>(m) {}
+
+    static inline SquareMatrix<T, N> identity() {
+      SquareMatrix<T, N> res;
+      for (unsigned i = 0; i < N; i++)
+	res(i, i) = 1;
+      return res;
+    }
+  };
+
+
+  //
+  // Vector external functions
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  //  template <class T, unsigned N>
+  //  inline Vec<T, N> operator+(const Vec<T, N>& v1,
+  //				const Vec<T, N>& v2) {
+  //    Vec<T, N> res(v1);
+  //    res += v2;
+  //    return res;
+  //  }
+  //
+  //  template <class T, unsigned N>
+  //  inline Vec<T, N> operator-(const Vec<T, N>& v1,
+  //				const Vec<T, N>& v2) {
+  //    Vec<T, N> res(v1);
+  //    res -= v2;
+  //    return res;
+  //  }
+  //  template <class T, unsigned N>
+  //    inline Vec<T, N> operator*(const Vec<T, N>& v,
+  //				const typename Vec<T, N>::value_type r) {
+  //    Vec<T, N> res(v);
+  //    res *= r;
+  //    return res;
+  //  }
+  
+  template <class T, unsigned N>
+    inline Vec<T, N> operator*(const typename Vec<T, N>::value_type r,
+				const Vec<T, N>& v) {
+    Vec<T, N> res(v);
+    res *= r;
+    return res;
+  }
+  //
+  //  template <class T, unsigned N>
+  //  inline Vec<T, N> operator/(const Vec<T, N>& v,
+  //				const typename Vec<T, N>::value_type r) {
+  //    Vec<T, N> res(v);
+  //    if (r)
+  //      res /= r;
+  //    return res;
+  //  }
+  //
+  // dot product
+  //  template <class T, unsigned N>
+  //    inline typename Vec<T, N>::value_type operator*(const Vec<T, N>& v1,
+  //    const Vec<T, N>& v2) {
+  //    typename Vec<T, N>::value_type sum = 0;
+  //    for (unsigned i = 0; i < N; i++)
+  //      sum += v1[i] * v2[i];
+  //    return sum;
+  //  }
+  //
+  //  // cross product for 3D Vectors
+  //  template <typename T>
+  //  inline Vec3<T> operator^(const Vec<T, 3>& v1,
+  //			   const Vec<T, 3>& v2) {
+  //    Vec3<T> res(v1[1] * v2[2] - v1[2] * v2[1],
+  //		v1[2] * v2[0] - v1[0] * v2[2],
+  //		v1[0] * v2[1] - v1[1] * v2[0]);
+  //    return res;
+  //  }
+
+  // stream operator
+  template <class T, unsigned N>
+  inline std::ostream& operator<<(std::ostream& s,
+				  const Vec<T, N>& v) {
+    unsigned i;
+    s << "[";
+    for (i = 0; i < N - 1; i++)
+      s << v[i] << ", ";
+    s << v[i] << "]";
+    return s;
+  }
+
+
+  //
+  // Matrix external functions
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  template <class T, unsigned M, unsigned N>
+  inline Matrix<T, M, N>
+  operator+(const Matrix<T, M, N>& m1,
+	    const Matrix<T, M, N>& m2) {
+    Matrix<T, M, N> res(m1);
+    res += m2;
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N>
+  inline Matrix<T, M, N>
+  operator-(const Matrix<T, M, N>& m1,
+	    const Matrix<T, M, N>& m2) {
+    Matrix<T, M, N> res(m1);
+    res -= m2;
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N>
+  inline Matrix<T, M, N>
+  operator*(const Matrix<T, M, N>& m1,
+	    const typename Matrix<T, M, N>::value_type lambda) {
+    Matrix<T, M, N> res(m1);
+    res *= lambda;
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N>
+  inline Matrix<T, M, N>
+  operator*(const typename Matrix<T, M, N>::value_type lambda,
+	    const Matrix<T, M, N>& m1) {
+    Matrix<T, M, N> res(m1);
+    res *= lambda;
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N>
+  inline Matrix<T, M, N>
+  operator/(const Matrix<T, M, N>& m1,
+	    const typename Matrix<T, M, N>::value_type lambda) {
+    Matrix<T, M, N> res(m1);
+    res /= lambda;
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N, unsigned P>
+  inline Matrix<T, M, P>
+  operator*(const Matrix<T, M, N>& m1,
+	    const Matrix<T, N, P>& m2) {
+    unsigned i, j, k;
+    Matrix<T, M, P> res;
+    typename  Matrix<T, N, P>::value_type scale;
+  
+    for (j = 0; j < P; j++) {
+      for (k = 0; k < N; k++) {
+	scale = m2(k, j);
+	for (i = 0; i < N; i++)
+	  res(i, j) += m1(i, k) * scale;
+      }
+    }
+    return res;
+  }
+
+  template <class T, unsigned M, unsigned N>
+  inline Vec<T, M>
+  operator*(const Matrix<T, M, N>& m,
+	    const Vec<T, N>& v) {
+  
+    Vec<T, M> res;
+    typename Matrix<T, M, N>::value_type scale;
+  
+    for (unsigned j = 0; j < M; j++) {
+      scale = v[j];
+      for (unsigned i = 0; i < N; i++)
+	res[i] += m(i, j) * scale;
+    }
+    return res;
+  }
+
+  // stream operator
+  template <class T, unsigned M, unsigned N>
+  inline std::ostream& operator<<(std::ostream& s,
+				  const Matrix<T, M, N>& m) {
+    unsigned i, j;
+    for (i = 0; i < M; i++) {
+      s << "[";
+      for (j = 0; j < N - 1; j++)
+	s << m(i, j) << ", ";
+      s << m(i, j) << "]" << std::endl;
+    }
+    return s;
+  }
+
+} // end of namespace VecMat
+
+#endif // VECMAT_H
diff --git a/source/blender/freestyle/intern/geometry/geometry.pro b/source/blender/freestyle/intern/geometry/geometry.pro
new file mode 100755
index 00000000000..a63aa6483b4
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/geometry.pro
@@ -0,0 +1,64 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+TARGET          = $${LIB_GEOMETRY}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES   *= MAKE_LIB_GEOMETRY_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../system
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/intern/geometry/matrix_util.cpp b/source/blender/freestyle/intern/geometry/matrix_util.cpp
new file mode 100755
index 00000000000..2117b06e62f
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/matrix_util.cpp
@@ -0,0 +1,265 @@
+/*
+ *  GXML/Graphite: Geometry and Graphics Programming Library + Utilities
+ *  Copyright (C) 2000 Bruno Levy
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  If you modify this software, you should include a notice giving the
+ *  name of the person performing the modification, the date of modification,
+ *  and the reason for such modification.
+ *
+ *  Contact: Bruno Levy
+ *
+ *     levy@loria.fr
+ *
+ *     ISA Project
+ *     LORIA, INRIA Lorraine, 
+ *     Campus Scientifique, BP 239
+ *     54506 VANDOEUVRE LES NANCY CEDEX 
+ *     FRANCE
+ *
+ *  Note that the GNU General Public License does not permit incorporating
+ *  the Software into proprietary programs. 
+ */
+
+
+#include "matrix_util.h"
+#include <math.h>
+
+
+
+namespace OGF {
+    
+    namespace MatrixUtil {
+
+        static const double EPS = 0.00001 ;
+        static int MAX_ITER = 100 ;
+        
+        void semi_definite_symmetric_eigen(
+            const double *mat, int n, double *eigen_vec, double *eigen_val
+        ) {
+            double *a,*v;
+            double a_norm,a_normEPS,thr,thr_nn;
+            int nb_iter = 0;
+            int jj;
+            int i,j,k,ij,ik,l,m,lm,mq,lq,ll,mm,imv,im,iq,ilv,il,nn;
+            int *index;
+            double a_ij,a_lm,a_ll,a_mm,a_im,a_il;
+            double a_lm_2;
+            double v_ilv,v_imv;
+            double x;
+            double sinx,sinx_2,cosx,cosx_2,sincos;
+            double delta;
+        
+            // Number of entries in mat
+        
+            nn = (n*(n+1))/2;
+        
+            // Step 1: Copy mat to a
+        
+            a = new double[nn];
+        
+            for( ij=0; ij<nn; ij++ ) {
+                a[ij] = mat[ij];
+            }
+        
+            // Ugly Fortran-porting trick: indices for a are between 1 and n
+            a--;
+        
+            // Step 2 : Init diagonalization matrix as the unit matrix
+            v = new double[n*n];
+        
+            ij = 0;
+            for( i=0; i<n; i++ ) {
+                for( j=0; j<n; j++ ) {
+                    if( i==j ) {
+                        v[ij++] = 1.0;
+                    } else {
+                        v[ij++] = 0.0;
+                    }
+                }
+            }
+        
+            // Ugly Fortran-porting trick: indices for v are between 1 and n
+            v--;
+        
+            // Step 3 : compute the weight of the non diagonal terms 
+            ij     = 1  ;
+            a_norm = 0.0;
+            for( i=1; i<=n; i++ ) {
+                for( j=1; j<=i; j++ ) {
+                    if( i!=j ) {
+                        a_ij    = a[ij];
+                        a_norm += a_ij*a_ij;
+                    }
+                    ij++;
+                }
+            }
+        
+            if( a_norm != 0.0 ) {
+        
+                a_normEPS = a_norm*EPS;
+                thr       = a_norm    ;
+    
+                // Step 4 : rotations
+                while( thr > a_normEPS   &&   nb_iter < MAX_ITER ) {
+        
+                    nb_iter++;
+                    thr_nn = thr / nn;
+            
+                    for( l=1  ; l< n; l++ ) {
+                        for( m=l+1; m<=n; m++ ) {
+                    
+                            // compute sinx and cosx 
+                    
+                            lq   = (l*l-l)/2;
+                            mq   = (m*m-m)/2;
+                    
+                            lm     = l+mq;
+                            a_lm   = a[lm];
+                            a_lm_2 = a_lm*a_lm;
+                    
+                            if( a_lm_2 < thr_nn ) {
+                                continue ;
+                            }
+                    
+                            ll   = l+lq;
+                            mm   = m+mq;
+                            a_ll = a[ll];
+                            a_mm = a[mm];
+                    
+                            delta = a_ll - a_mm;
+                    
+                            if( delta == 0.0 ) {
+                                x = - M_PI/4 ; 
+                            } else {
+                                x = - atan( (a_lm+a_lm) / delta ) / 2.0 ;
+                            }
+
+                            sinx    = sin(x)   ;
+                            cosx    = cos(x)   ;
+                            sinx_2  = sinx*sinx;
+                            cosx_2  = cosx*cosx;
+                            sincos  = sinx*cosx;
+                    
+                            // rotate L and M columns 
+       
+                            ilv = n*(l-1);
+                            imv = n*(m-1);
+                    
+                            for( i=1; i<=n;i++ ) {
+                                if( (i!=l) && (i!=m) ) {
+                                    iq = (i*i-i)/2;
+                            
+                                    if( i<m )  { 
+                                        im = i + mq; 
+                                    } else {
+                                        im = m + iq;
+                                    }
+                                    a_im = a[im];
+                            
+                                    if( i<l ) {
+                                        il = i + lq; 
+                                    } else {
+                                        il = l + iq;
+                                    }
+                                    a_il = a[il];
+                            
+                                    a[il] =  a_il*cosx - a_im*sinx;
+                                    a[im] =  a_il*sinx + a_im*cosx;
+                                }
+                        
+                                ilv++;
+                                imv++;
+                        
+                                v_ilv = v[ilv];
+                                v_imv = v[imv];
+                        
+                                v[ilv] = cosx*v_ilv - sinx*v_imv;
+                                v[imv] = sinx*v_ilv + cosx*v_imv;
+                            } 
+                    
+                            x = a_lm*sincos; x+=x;
+                    
+                            a[ll] =  a_ll*cosx_2 + a_mm*sinx_2 - x;
+                            a[mm] =  a_ll*sinx_2 + a_mm*cosx_2 + x;
+                            a[lm] =  0.0;
+                    
+                            thr = fabs( thr - a_lm_2 );
+                        }
+                    }
+                }         
+            }
+        
+            // Step 5: index conversion and copy eigen values 
+        
+            // back from Fortran to C++
+            a++;
+        
+            for( i=0; i<n; i++ ) {
+                k = i + (i*(i+1))/2;
+                eigen_val[i] = a[k];
+            }
+     
+            delete[] a;
+        
+            // Step 6: sort the eigen values and eigen vectors 
+        
+            index = new int[n];
+            for( i=0; i<n; i++ ) {
+                index[i] = i;
+            }
+        
+            for( i=0; i<(n-1); i++ ) {
+                x = eigen_val[i];
+                k = i;
+            
+                for( j=i+1; j<n; j++ ) {
+                    if( x < eigen_val[j] ) {
+                        k = j;
+                        x = eigen_val[j];
+                    }
+                }
+            
+                eigen_val[k] = eigen_val[i];
+                eigen_val[i] = x;
+          
+                jj       = index[k];
+                index[k] = index[i];
+                index[i] = jj;
+            }
+
+
+            // Step 7: save the eigen vectors 
+    
+            v++; // back from Fortran to to C++
+        
+            ij = 0;
+            for( k=0; k<n; k++ ) {
+                ik = index[k]*n;
+                for( i=0; i<n; i++ ) {
+                    eigen_vec[ij++] = v[ik++];
+                }
+            }
+    
+            delete[] v    ;
+            delete[] index;
+            return;
+        }
+    
+//_________________________________________________________
+
+    }
+}
diff --git a/source/blender/freestyle/intern/geometry/matrix_util.h b/source/blender/freestyle/intern/geometry/matrix_util.h
new file mode 100755
index 00000000000..a990413c403
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/matrix_util.h
@@ -0,0 +1,69 @@
+/*
+ *  GXML/Graphite: Geometry and Graphics Programming Library + Utilities
+ *  Copyright (C) 2000 Bruno Levy
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  If you modify this software, you should include a notice giving the
+ *  name of the person performing the modification, the date of modification,
+ *  and the reason for such modification.
+ *
+ *  Contact: Bruno Levy
+ *
+ *     levy@loria.fr
+ *
+ *     ISA Project
+ *     LORIA, INRIA Lorraine, 
+ *     Campus Scientifique, BP 239
+ *     54506 VANDOEUVRE LES NANCY CEDEX 
+ *     FRANCE
+ *
+ *  Note that the GNU General Public License does not permit incorporating
+ *  the Software into proprietary programs. 
+ */
+
+#ifndef __MATRIX_UTIL__
+#define __MATRIX_UTIL__
+
+# include "../system/FreestyleConfig.h"
+
+namespace OGF {
+
+    namespace MatrixUtil {
+
+        /**
+         * computes the eigen values and eigen vectors   
+         * of a semi definite symmetric matrix
+         *
+         * @param  matrix is stored in column symmetric storage, i.e.
+         *     matrix = { m11, m12, m22, m13, m23, m33, m14, m24, m34, m44 ... }
+         *     size = n(n+1)/2
+         *
+         * @param eigen_vectors (return) = { v1, v2, v3, ..., vn } 
+         *   where vk = vk0, vk1, ..., vkn
+         *     size = n^2, must be allocated by caller
+         *
+         * @param eigen_values  (return) are in decreasing order
+         *     size = n,   must be allocated by caller
+         */
+        LIB_GEOMETRY_EXPORT 
+        void semi_definite_symmetric_eigen(
+            const double *mat, int n, double *eigen_vec, double *eigen_val
+        ) ;
+    
+    }
+}
+
+#endif
diff --git a/source/blender/freestyle/intern/geometry/normal_cycle.cpp b/source/blender/freestyle/intern/geometry/normal_cycle.cpp
new file mode 100755
index 00000000000..b456ced8331
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/normal_cycle.cpp
@@ -0,0 +1,103 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "normal_cycle.h"
+#include "matrix_util.h"
+
+
+namespace OGF {
+
+//_________________________________________________________
+    
+
+    NormalCycle::NormalCycle() {
+    }
+
+    void NormalCycle::begin() {
+        M_[0] = M_[1] = M_[2] = M_[3] = M_[4] = M_[5] = 0 ;
+    }
+    
+    void NormalCycle::end() {
+        
+        double eigen_vectors[9] ;
+        MatrixUtil::semi_definite_symmetric_eigen(M_, 3, eigen_vectors, eigen_value_) ;
+            
+        axis_[0] = Vec3r(
+            eigen_vectors[0], eigen_vectors[1], eigen_vectors[2]
+        ) ;
+            
+        axis_[1] = Vec3r(
+            eigen_vectors[3], eigen_vectors[4], eigen_vectors[5]
+        ) ;
+        
+        axis_[2] = Vec3r(
+            eigen_vectors[6], eigen_vectors[7], eigen_vectors[8]
+        ) ;
+        
+        // Normalize the eigen vectors
+        
+        for(int i=0; i<3; i++) {
+            axis_[i].normalize() ;
+        }
+
+        // Sort the eigen vectors
+
+        i_[0] = 0 ;
+        i_[1] = 1 ;
+        i_[2] = 2 ;
+
+        double l0 = ::fabs(eigen_value_[0]) ;
+        double l1 = ::fabs(eigen_value_[1]) ;
+        double l2 = ::fabs(eigen_value_[2]) ;
+        
+        if(l1 > l0) {
+            ogf_swap(l0   , l1   ) ;
+            ogf_swap(i_[0], i_[1]) ;
+        }
+        if(l2 > l1) {
+            ogf_swap(l1   , l2   ) ;
+            ogf_swap(i_[1], i_[2]) ;
+        }
+        if(l1 > l0) {
+            ogf_swap(l0   , l1  ) ;
+            ogf_swap(i_[0],i_[1]) ;
+        }
+
+    }
+
+    void NormalCycle::accumulate_dihedral_angle(
+        const Vec3r& edge, double beta, double neigh_area
+    ) {
+        Vec3r e = edge ;
+        e.normalize() ;
+
+        double s = edge.norm() * beta * neigh_area ;
+
+        M_[0] += s * e.x() * e.x() ;
+        M_[1] += s * e.x() * e.y() ;
+        M_[2] += s * e.y() * e.y() ;
+        M_[3] += s * e.x() * e.z() ;
+        M_[4] += s * e.y() * e.z() ;
+        M_[5] += s * e.z() * e.z() ;        
+    }
+    
+//_________________________________________________________
+
+}
diff --git a/source/blender/freestyle/intern/geometry/normal_cycle.h b/source/blender/freestyle/intern/geometry/normal_cycle.h
new file mode 100755
index 00000000000..41fbf7b3fab
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/normal_cycle.h
@@ -0,0 +1,97 @@
+/*
+ *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
+ *  Copyright (C) 2000 Bruno Levy
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  If you modify this software, you should include a notice giving the
+ *  name of the person performing the modification, the date of modification,
+ *  and the reason for such modification.
+ *
+ *  Contact: Bruno Levy
+ *
+ *     levy@loria.fr
+ *
+ *     ISA Project
+ *     LORIA, INRIA Lorraine, 
+ *     Campus Scientifique, BP 239
+ *     54506 VANDOEUVRE LES NANCY CEDEX 
+ *     FRANCE
+ *
+ *  Note that the GNU General Public License does not permit incorporating
+ *  the Software into proprietary programs. 
+ */
+
+#ifndef __MESH_TOOLS_MATH_NORMAL_CYCLE__
+#define __MESH_TOOLS_MATH_NORMAL_CYCLE__
+
+# include "../system/FreestyleConfig.h"
+# include "Geom.h"
+using namespace Geometry;
+ 
+namespace OGF {
+
+template <class T> inline void ogf_swap(T& x, T& y) {
+        T z = x ;
+        x = y ;
+        y = z ;
+    }
+
+//_________________________________________________________
+
+    /**
+     * NormalCycle evaluates the curvature tensor in function
+     * of a set of dihedral angles and associated vectors.
+     * Reference:
+     *    Restricted Delaunay Triangulation and Normal Cycle,
+     *    D. Cohen-Steiner and J.M. Morvan,
+     *    SOCG 2003
+     */
+    class LIB_GEOMETRY_EXPORT NormalCycle {
+    public:
+        NormalCycle() ;
+        void begin() ;
+        void end() ;
+        /**
+         * Note: the specified edge vector needs to be pre-clipped
+         * by the neighborhood.
+         */
+        void accumulate_dihedral_angle(
+            const Vec3r& edge, real angle, real neigh_area = 1.0
+        ) ;
+        const Vec3r& eigen_vector(int i) const { return axis_[i_[i]] ; }
+        real eigen_value(int i) const   { return eigen_value_[i_[i]] ;  } 
+
+        const Vec3r& N() const    { return eigen_vector(2) ; }
+        const Vec3r& Kmax() const { return eigen_vector(1) ; }
+        const Vec3r& Kmin() const { return eigen_vector(0) ; }
+
+        real n() const    { return eigen_value(2) ; }
+        real kmax() const { return eigen_value(1) ; }
+        real kmin() const { return eigen_value(0) ; }
+
+    private:
+        real center_[3] ;
+        Vec3r axis_[3] ;
+        real eigen_value_[3] ;
+        real M_[6] ;
+        int i_[3] ;
+    } ;
+    
+//_________________________________________________________
+
+}
+
+#endif
diff --git a/source/blender/freestyle/intern/geometry/src.pri b/source/blender/freestyle/intern/geometry/src.pri
new file mode 100755
index 00000000000..a35760fe892
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/src.pri
@@ -0,0 +1,33 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+GEOMETRY_DIR = ../geometry
+
+SOURCES *= $${GEOMETRY_DIR}/GeomCleaner.cpp \
+           $${GEOMETRY_DIR}/GeomUtils.cpp \
+           $${GEOMETRY_DIR}/Grid.cpp \
+           $${GEOMETRY_DIR}/FastGrid.cpp \
+           $${GEOMETRY_DIR}/HashGrid.cpp \
+           $${GEOMETRY_DIR}/FitCurve.cpp \
+           $${GEOMETRY_DIR}/Bezier.cpp \
+           $${GEOMETRY_DIR}/Noise.cpp \
+           $${GEOMETRY_DIR}/matrix_util.cpp \
+           $${GEOMETRY_DIR}/normal_cycle.cpp
+
+HEADERS *= $${GEOMETRY_DIR}/BBox.h \
+           $${GEOMETRY_DIR}/FastGrid.h \
+           $${GEOMETRY_DIR}/Geom.h \
+           $${GEOMETRY_DIR}/GeomCleaner.h \
+           $${GEOMETRY_DIR}/GeomUtils.h \
+           $${GEOMETRY_DIR}/Grid.h \
+           $${GEOMETRY_DIR}/HashGrid.h \
+           $${GEOMETRY_DIR}/Polygon.h \
+           $${GEOMETRY_DIR}/SweepLine.h \
+           $${GEOMETRY_DIR}/FitCurve.h \
+           $${GEOMETRY_DIR}/Bezier.h \
+           $${GEOMETRY_DIR}/Noise.h \
+           $${GEOMETRY_DIR}/VecMat.h \
+           $${GEOMETRY_DIR}/matrix_util.h \
+           $${GEOMETRY_DIR}/normal_cycle.h
diff --git a/source/blender/freestyle/intern/image/GaussianFilter.cpp b/source/blender/freestyle/intern/image/GaussianFilter.cpp
new file mode 100755
index 00000000000..3a79f5f9949
--- /dev/null
+++ b/source/blender/freestyle/intern/image/GaussianFilter.cpp
@@ -0,0 +1,96 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GaussianFilter.h"
+#include <stdlib.h>
+
+GaussianFilter::GaussianFilter(float iSigma )
+{
+  _sigma = iSigma;
+  _mask = 0;
+  computeMask();
+}
+
+GaussianFilter::GaussianFilter(const GaussianFilter& iBrother) 
+{
+  _sigma = iBrother._sigma;
+  _maskSize = iBrother._maskSize;
+  _bound = iBrother._bound;
+  _storedMaskSize = iBrother._storedMaskSize;
+  _mask = new float[_maskSize*_maskSize];
+  memcpy(_mask, iBrother._mask, _maskSize*_maskSize*sizeof(float));
+}
+
+
+GaussianFilter& GaussianFilter::operator= (const GaussianFilter& iBrother) 
+{
+  _sigma = iBrother._sigma;
+  _maskSize = iBrother._maskSize;
+  _bound = iBrother._bound;
+  _storedMaskSize = iBrother._storedMaskSize;
+  _mask = new float[_storedMaskSize*_storedMaskSize];
+  memcpy(_mask, iBrother._mask, _storedMaskSize*_storedMaskSize*sizeof(float));
+  return *this;
+}
+
+
+GaussianFilter::~GaussianFilter()
+{
+  if(0!=_mask)
+  {
+    delete [] _mask;
+  }
+}
+
+int GaussianFilter::computeMaskSize(float sigma)
+{
+  int maskSize = (int)floor(4*sigma)+1;
+  if(0 == maskSize%2)
+    ++maskSize;
+
+  return maskSize;
+}
+
+void GaussianFilter::setSigma(float sigma)
+{
+  _sigma = sigma;
+  computeMask();
+}
+
+void GaussianFilter::computeMask()
+{
+  if(0 != _mask){
+    delete [] _mask;
+  }
+
+  _maskSize = computeMaskSize(_sigma);
+  _storedMaskSize = (_maskSize+1)>>1;
+  _bound = _storedMaskSize-1;
+
+  float norm = _sigma*_sigma*2.f*M_PI; 
+  float invNorm = 1.0/norm;
+  _mask = new float[_storedMaskSize*_storedMaskSize*sizeof(float)];
+  for(int i=0; i<_storedMaskSize; ++i)
+    for(int j=0; j<_storedMaskSize; ++j)
+      _mask[i*_storedMaskSize+j] = invNorm*exp(-(i*i + j*j)/(2.0*_sigma*_sigma));
+      //_mask[i*_storedMaskSize+j] = exp(-(i*i + j*j)/(2.0*_sigma*_sigma));
+}
+
diff --git a/source/blender/freestyle/intern/image/GaussianFilter.h b/source/blender/freestyle/intern/image/GaussianFilter.h
new file mode 100755
index 00000000000..f31b500140f
--- /dev/null
+++ b/source/blender/freestyle/intern/image/GaussianFilter.h
@@ -0,0 +1,144 @@
+//
+//  Filename         : Image.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to perform gaussian filtering operations on an image
+//  Date of creation : 20/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GAUSSIANFILTER_H
+# define GAUSSIANFILTER_H
+
+#include "../system/FreestyleConfig.h"
+
+class LIB_IMAGE_EXPORT GaussianFilter{
+protected:
+  /* the mask is a symetrical 2d array (with respect 
+  to the middle point). 
+  Thus, M(i,j) = M(-i,j) = M(i,-j) = M(-i,-j).
+  For this reason, to represent a NxN array (N odd), we only store
+  a ((N+1)/2)x((N+1)/2) array.
+  */
+  float _sigma;
+  float *_mask;
+  int _bound;
+  int _maskSize; // the real mask size (must be odd)(the size of the mask we store is ((_maskSize+1)/2)*((_maskSize+1)/2))
+  int _storedMaskSize; //(_maskSize+1)/2)
+ 
+public:
+  GaussianFilter(float iSigma = 1.f) ;
+  GaussianFilter(const GaussianFilter&) ;
+  GaussianFilter& operator= (const GaussianFilter&) ;
+  virtual ~GaussianFilter() ;
+
+  /*! Returns the value for pixel x,y of image "map" after a gaussian blur, 
+   *  made using the sigma value.
+   *  The sigma value determines the mask size (~ 2 x sigma).
+   *  \param map
+   *    The image we wish to work on. The Map template must implement the 
+   *    foloowing methods: 
+   *    - float pixel(unsigned int x,unsigned int y) const;
+   *    - unsigned width() const;
+   *    - unsigned height() const;
+   *  \param x
+   *    The abscissa of the pixel where we want to evaluate the gaussian blur.
+   *  \param y
+   *    The ordinate of the pixel where we want to evaluate the gaussian blur.
+   *  \param sigma
+   *    The sigma value of the gaussian function.
+   */
+  template<class Map>
+  float getSmoothedPixel(Map * map, int x, int y) ;
+  
+  /*! Compute the mask size and returns the REAL mask size ((2*_maskSize)-1)
+   *  This method is provided for convenience.
+   */
+  static int computeMaskSize(float sigma) ;
+
+  /*! accessors */
+  inline float sigma() const {return _sigma;}
+  inline int maskSize() const {return _maskSize;}
+  inline int getBound() {return _bound;}
+
+  /*! modifiers */
+  void setSigma(float sigma) ;
+  // void SetMaskSize(int size) {_maskSize = size;_storedMaskSize=(_maskSize+1)>>1;}
+  
+    
+protected:
+  void computeMask();
+};
+
+/*
+  
+  #############################################
+  #############################################
+  #############################################
+  ######                                 ######
+  ######   I M P L E M E N T A T I O N   ######
+  ######                                 ######
+  #############################################
+  #############################################
+  #############################################
+  
+*/
+
+
+#include <math.h>
+
+#ifdef __MACH__
+#define sqrtf(x) (sqrt(x))
+#endif
+
+template<class Map>
+float GaussianFilter::getSmoothedPixel(Map * map, int x, int y)
+{
+  float sum = 0.f;  
+  float L=0.f;
+  int w = (int)map->width(); //soc
+  int h = (int)map->height(); //soc
+
+  // Current pixel is x,y
+  // Sum surrounding pixels L value:
+  for(int i=-_bound; i<=_bound; ++i)
+  {
+    if((y+i < 0) || (y+i >= h))
+      continue;
+    for(int j=-_bound; j<=_bound; ++j)
+    {
+      if((x+j < 0) || (x+j >= w))
+        continue;
+      
+      float tmpL = map->pixel(x+j,y+i);
+      float m = _mask[abs(i)*_storedMaskSize+abs(j)];
+      L += m*tmpL;
+      sum += m;
+    }
+  }
+  //L /= sum;
+  return L;
+}
+
+
+#endif // GAUSSIANFILTER
diff --git a/source/blender/freestyle/intern/image/Image.h b/source/blender/freestyle/intern/image/Image.h
new file mode 100755
index 00000000000..83d6785e32f
--- /dev/null
+++ b/source/blender/freestyle/intern/image/Image.h
@@ -0,0 +1,389 @@
+//
+//  Filename         : Image.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to encapsulate an array of RGB or Gray level values
+//  Date of creation : 20/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  IMAGE_H
+# define IMAGE_H
+
+# include <string> // for memcpy
+
+//
+// Image base class, for all types of images
+//
+///////////////////////////////////////////////////////////////////////////////
+
+/*! This class allows the storing of part of an image, 
+ *  while allowing a normal access to its pixel values.
+ *  You can for example only a rectangle of sw*sh, whose 
+ *  lower-left corner is at (ox, oy), of an image of 
+ *  size w*h, and access these pixels using x,y coordinates 
+ *  specified in the whole image coordinate system.
+ */
+class Image
+{
+ public:
+
+   /*! Default constructor */
+  Image() {
+    _storedWidth = 0;
+    _storedHeight = 0;
+    _width = 0;
+    _height = 0;
+    _Ox = 0;
+    _Oy = 0;
+  }
+
+  /*! Copy constructor */
+  Image(const Image& brother) {
+    _storedWidth = brother._storedWidth;
+    _storedHeight = brother._storedHeight;
+    _width = brother._width;
+    _height = brother._height;
+    _Ox = brother._Ox;
+    _Oy = brother._Oy;
+  }
+
+  /*! Builds an image from its width and height.
+   *  The memory is allocated consequently.
+   */
+  Image(unsigned w, unsigned h) {
+    _width = w;
+    _height = h;
+    _storedWidth = w;
+    _storedHeight = h;
+    _Ox = 0;
+    _Oy = 0;
+  }
+
+  /*! Builds a partial-storing image. 
+   *  \param w
+   *    The width of the complete image
+   *  \param h
+   *    The height of the complete image
+   *  \param sw
+   *    The width of the rectangle that will actually 
+   *    be stored.
+   *  \param sh
+   *    The height of the rectangle that will actually 
+   *    be stored.
+   *  \param ox
+   *    The x-abscissa of the origin of the rectangle that will actually 
+   *    be stored.
+   *  \param oy
+   *    The x-abscissa of the origin of the rectangle that will actually 
+   *    be stored.
+   */
+  Image(unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) {
+    _width = w;
+    _height = h;
+    _storedWidth = sw;
+    _storedHeight = sh;
+    _Ox = ox;
+    _Oy = oy;
+  }
+
+  /*! Operator= */
+  Image& operator=(const Image& brother) {
+    _width = brother._width;
+    _height = brother._height;
+    _storedWidth = brother._storedWidth;
+    _storedHeight = brother._storedHeight;
+    _Ox = brother._Ox;
+    _Oy = brother._Oy;
+    return* this;
+  }
+
+  /*! Destructor */
+  virtual ~Image() {}
+
+  /*! Returns the width of the complete image */
+  inline unsigned width() const {
+    return _width;
+  }
+  /*! Returns the height of the complete image */
+  inline unsigned height() const {
+    return _height;
+  }
+  
+  /*! Returns the grey value for pixel x,y */
+  virtual float pixel(unsigned x, unsigned y) const = 0;
+
+  /*! Sets the array.
+   *  \param array
+   *    The array containing the values we wish to store.
+   *    Its size is sw*sh.
+   *  \param width
+   *    The width of the complete image
+   *  \param height
+   *    The height of the complete image
+   *  \param sw
+   *    The width of the rectangle that will actually 
+   *    be stored.
+   *  \param sh
+   *    The height of the rectangle that will actually 
+   *    be stored.
+   *  \param ox
+   *    The x-abscissa of the origin of the rectangle that will actually 
+   *    be stored.
+   *  \param oy
+   *    The x-abscissa of the origin of the rectangle that will actually 
+   *    be stored.
+   *  \param copy
+   *    If true, the array is copied, otherwise the pointer is 
+   *    copied
+   */
+  virtual void setArray(float* array, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) = 0;
+  
+  /*! Returns the array containing the pixels values.
+   *  Its size is sw*sh, i.e. potentially a smaller 
+   *  rectangular part of the complete image.
+   */
+  virtual float * getArray() = 0;
+
+ protected:
+
+  unsigned	_width;
+  unsigned	_height;
+  unsigned _storedWidth;
+  unsigned _storedHeight;
+  unsigned _Ox; // origin of the stored part
+  unsigned _Oy; // origin of the stored part
+};
+
+
+//
+// RGBImage
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class RGBImage : public Image
+{
+ public:
+
+  RGBImage() : Image() {
+    _rgb = 0;
+  }
+
+  RGBImage(const RGBImage& brother) : Image(brother) {
+    _rgb = new float[3 * _storedWidth * _storedHeight];
+    memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
+  }
+
+  RGBImage(unsigned w, unsigned h) : Image(w, h) {
+    _rgb = new float[3 * _width * _height];
+  }
+
+  RGBImage(float* rgb, unsigned w, unsigned h) : Image(w, h) {
+    _rgb = new float[3 * _width * _height];
+    memcpy(_rgb, rgb, 3 * _width * _height * sizeof(float));
+  }
+  
+  /*! Builds an RGB partial image from the useful part buffer.
+   *  \param rgb
+   *    The array of size 3*sw*sh containing the RGB values 
+   *    of the sw*sh pixels we need to stored.
+   *    These sw*sh pixels constitute a rectangular part of 
+   *    a bigger RGB image containing w*h pixels.
+   *  \param w
+   *    The width of the complete image
+   *  \param h
+   *    The height of the complete image
+   *  \param sw
+   *    The width of the part of the image we want to store and work on
+   *  \param sh
+   *    The height of the part of the image we want to store and work on
+   */
+  RGBImage(float* rgb, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) : Image(w, h, sw, sh, ox, oy) {
+    _rgb = new float[3 * _storedWidth * _storedHeight];
+    memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
+  }
+
+  RGBImage& operator=(const RGBImage& brother) {
+    dynamic_cast<Image&>(*this) = brother;
+    _rgb = new float[3 * _storedWidth * _storedHeight];
+    memcpy(_rgb, brother._rgb, 3 * _storedWidth * _storedHeight * sizeof(float));
+    return* this;
+  }
+
+  virtual ~RGBImage() {
+    if(_rgb)
+      delete[] _rgb;
+  }
+
+  inline float getR(unsigned x, unsigned y) const {
+    return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3];
+  }
+
+  inline float getG(unsigned x, unsigned y) const {
+    return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3 + 1];
+  }
+
+  inline float getB(unsigned x, unsigned y) const {
+    return _rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3 + 2];
+  }
+
+  virtual void setPixel(unsigned x, unsigned y, float r, float g, float b){
+    float * tmp = &(_rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3]);
+    *tmp = r;++tmp;
+    *tmp = g;++tmp;
+    *tmp = b;
+  }
+
+  virtual float pixel(unsigned x, unsigned y) const  {
+    float res = 0;
+    float* tmp = &(_rgb[3 * (y-_Oy) * _storedWidth + (x-_Ox) * 3]);
+    res += 11 * (*tmp++);
+    res += 16 * (*tmp++);
+    res += 5 * (*tmp);
+    return res / 32;
+  }
+
+  /*! Sets the RGB array.
+   *    copy
+   *      If true, the array is copied, otherwise the pointer is 
+   *      copied
+   */
+  virtual void setArray(float* rgb, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) {
+    _width = width;
+    _height = height;
+    _storedWidth = sw;
+    _storedHeight = sh;
+    _Ox = x;
+    _Oy = y;
+    if(!copy) {
+      _rgb = rgb;
+      return;
+    }
+  
+    memcpy(_rgb, rgb, 3 * _storedWidth * _storedHeight* sizeof(float));
+  }
+
+  virtual float * getArray() {return _rgb;}
+
+ protected:
+
+  float*	_rgb;
+};
+
+
+//
+// GrayImage
+//
+///////////////////////////////////////////////////////////////////////////////
+
+class GrayImage : public Image
+{
+ public:
+
+  GrayImage() : Image() {
+    _lvl = 0;
+  }
+
+  GrayImage(const GrayImage& brother) : Image(brother) {
+    _lvl = new float[_storedWidth*_storedHeight];
+    memcpy(_lvl, brother._lvl, _storedWidth*_storedHeight*sizeof(*_lvl));
+  }
+
+  /*! Builds an empty gray image */
+  GrayImage(unsigned w, unsigned h) : Image(w, h) {
+    _lvl = new float[_width*_height];
+  }
+
+  GrayImage(float* lvl, unsigned w, unsigned h) : Image(w, h) {
+    _lvl = new float[_width*_height];
+    memcpy(_lvl, lvl, _width*_height*sizeof(*_lvl));
+  }
+  
+  /*! Builds a partial image from the useful part buffer.
+   *  \param lvl
+   *    The array of size sw*sh containing the gray values 
+   *    of the sw*sh pixels we need to stored.
+   *    These sw*sh pixels constitute a rectangular part of 
+   *    a bigger gray image containing w*h pixels.
+   *  \param w
+   *    The width of the complete image
+   *  \param h
+   *    The height of the complete image
+   *  \param sw
+   *    The width of the part of the image we want to store and work on
+   *  \param sh
+   *    The height of the part of the image we want to store and work on
+   */
+  GrayImage(float* lvl, unsigned w, unsigned h, unsigned sw, unsigned sh, unsigned ox, unsigned oy) : Image(w, h, sw, sh, ox, oy) {
+    _lvl = new float[_storedWidth*_storedHeight];
+    memcpy(_lvl, lvl, _storedWidth*_storedHeight*sizeof(float));
+  }
+
+  GrayImage& operator=(const GrayImage& brother) {
+    dynamic_cast<Image&>(*this) = brother;
+    _lvl = new float[_storedWidth * _storedHeight];
+    memcpy(_lvl, brother._lvl, _storedWidth * _storedHeight * sizeof(float));
+  return *this;
+  }
+
+  virtual ~GrayImage() {
+    if(_lvl)
+      delete[] _lvl;
+  }
+
+  inline void setPixel(unsigned x, unsigned y, float v){
+    _lvl[(y-_Oy) * _storedWidth+ (x-_Ox)] = v;
+  } 
+
+  inline float pixel(unsigned x, unsigned y) const {
+    return _lvl[(y-_Oy) * _storedWidth+ (x-_Ox)];
+  }
+
+  /*! Sets the array.
+   *    copy
+   *      If true, the array is copie, otherwise the pounsigneder is 
+   *      copied
+   */
+  void setArray(float *lvl, unsigned width, unsigned height, unsigned sw, unsigned sh, unsigned x, unsigned y, bool copy = true) {
+    _width = width;
+    _height = height;
+    _storedWidth = sw;
+    _storedHeight = sh;
+    _Ox = x;
+    _Oy = y;
+    if(!copy) {  
+      _lvl = lvl;
+      return;
+    }
+  
+    memcpy(_lvl, lvl, _storedWidth * _storedHeight * sizeof(float));
+  }
+  /*! Returns the array containing the gray values. */
+  virtual float * getArray() {return _lvl;}
+
+ protected:
+
+  float *_lvl;
+};
+
+#endif // IMAGE_H
diff --git a/source/blender/freestyle/intern/image/ImagePyramid.cpp b/source/blender/freestyle/intern/image/ImagePyramid.cpp
new file mode 100755
index 00000000000..542ab7917e3
--- /dev/null
+++ b/source/blender/freestyle/intern/image/ImagePyramid.cpp
@@ -0,0 +1,166 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "ImagePyramid.h"
+#include "Image.h"
+#include "GaussianFilter.h"
+#include <iostream>
+
+using namespace std;
+
+//ImagePyramid::ImagePyramid(const GrayImage& level0, unsigned nbLevels){
+//  //BuildPyramid(level0,nbLevels);
+//}
+
+ImagePyramid::ImagePyramid(const ImagePyramid& iBrother){
+  if(!_levels.empty()){
+    for(vector<GrayImage*>::iterator im=_levels.begin(), imend=_levels.end();
+    im!=imend;
+    ++im){
+      _levels.push_back(new GrayImage(**im)); 
+    }
+  }
+}
+ImagePyramid::~ImagePyramid(){
+  if(!_levels.empty()){
+    for(vector<GrayImage*>::iterator im=_levels.begin(), imend=_levels.end();
+    im!=imend;
+    ++im){
+      delete (*im);
+    }
+    _levels.clear();
+  }
+}
+
+GrayImage * ImagePyramid::getLevel(int l){
+  return _levels[l];
+}
+
+float ImagePyramid::pixel(int x, int y, int level){
+  GrayImage *img = _levels[level];
+  if(0 == level){
+    return img->pixel(x,y);
+  }
+  unsigned int i  = 1<<level;
+  unsigned int sx = x>>level;
+  unsigned int sy = y>>level;
+  if(sx >= img->width())
+    sx = img->width()-1;
+  if(sy >= img->height())
+    sy = img->height()-1;
+  
+  // bilinear interpolation
+  float A = i*(sx+1)-x;
+  float B = x-i*sx;
+  float C = i*(sy+1)-y;
+  float D = y-i*sy;
+
+  float P1(0), P2(0);
+  P1 = A*img->pixel(sx,sy);
+  if(sx < img->width()-1){
+    if(x%i != 0)
+      P1 +=  B*img->pixel(sx+1,sy);
+  }else{
+    P1 +=  B*img->pixel(sx,sy);
+  }
+  if(sy<img->height()-1){
+    if(y%i != 0){
+      P2 = A*img->pixel(sx,sy+1);
+      if(sx < img->width()-1){
+        if(x%i != 0)
+          P2 += B*img->pixel(sx+1,sy+1);
+      }else{
+        P2 += B*img->pixel(sx,sy+1);
+      }
+    }
+  }else{
+    P2 = P1;
+  }
+  return (1.f/(float)(1<<2*level))*(C*P1 + D*P2);
+}
+
+int ImagePyramid::width(int level){
+  return _levels[level]->width();
+}
+
+int ImagePyramid::height(int level){
+  return _levels[level]->height();
+}
+
+GaussianPyramid::GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma)
+    : ImagePyramid()
+{
+  _sigma = iSigma;
+  BuildPyramid(level0,nbLevels);
+} 
+GaussianPyramid::GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma)
+    : ImagePyramid()
+{
+  _sigma = iSigma;
+  BuildPyramid(level0,nbLevels);
+}
+
+GaussianPyramid::GaussianPyramid(const GaussianPyramid& iBrother)
+: ImagePyramid(iBrother){
+  _sigma = iBrother._sigma;
+}
+void GaussianPyramid::BuildPyramid(const GrayImage& level0, unsigned nbLevels){
+  GrayImage *pLevel = new GrayImage(level0);
+  BuildPyramid(pLevel, nbLevels);
+}
+
+void GaussianPyramid::BuildPyramid(GrayImage* level0, unsigned nbLevels){
+  GrayImage *pLevel = level0;
+  _levels.push_back(pLevel);
+  GaussianFilter gf(_sigma);
+  // build the nbLevels:
+  unsigned w = pLevel->width();
+  unsigned h = pLevel->height();
+  if(nbLevels!=0)
+  {
+    for(unsigned i=0; i<nbLevels; ++i){ //soc
+      w = pLevel->width()>>1;
+      h = pLevel->height()>>1;
+      GrayImage *img = new GrayImage(w,h);
+      for(unsigned y=0; y<h; ++y){
+        for(unsigned x=0; x<w; ++x){
+          float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2*x,2*y);
+          img->setPixel(x,y,v);
+        } 
+      } 
+      _levels.push_back(img);
+      pLevel = img;
+    }
+  }else{
+    while((w>1) && (h>1)){
+      w = pLevel->width()>>1;
+      h = pLevel->height()>>1;
+      GrayImage *img = new GrayImage(w,h);
+      for(unsigned y=0; y<h; ++y){
+        for(unsigned x=0; x<w; ++x){
+          float v = gf.getSmoothedPixel<GrayImage>(pLevel, 2*x,2*y);
+          img->setPixel(x,y,v);
+        } 
+      } 
+      _levels.push_back(img);
+      pLevel = img;
+    } 
+  }
+}
diff --git a/source/blender/freestyle/intern/image/ImagePyramid.h b/source/blender/freestyle/intern/image/ImagePyramid.h
new file mode 100755
index 00000000000..9e326757f02
--- /dev/null
+++ b/source/blender/freestyle/intern/image/ImagePyramid.h
@@ -0,0 +1,92 @@
+//
+//  Filename         : ImagePyramid.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to represent a pyramid of images
+//  Date of creation : 25/12/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  IMAGEPYRAMID_H
+# define IMAGEPYRAMID_H
+
+#include "../system/FreestyleConfig.h"
+#include <vector>
+
+class GrayImage;
+class LIB_IMAGE_EXPORT ImagePyramid{
+protected:
+  std::vector<GrayImage*> _levels;
+  
+public:
+  ImagePyramid(){}
+  ImagePyramid(const ImagePyramid& iBrother);
+  //ImagePyramid(const GrayImage& level0, unsigned nbLevels);
+  virtual ~ImagePyramid();
+
+  /*! Builds the pyramid.
+   * must be overloaded by inherited classes.
+   * if nbLevels==0, the complete pyramid is built
+   */
+  virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels) = 0;
+  
+  /*! Builds a pyramid without copying the base level */
+  virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels) = 0;
+  
+  virtual GrayImage * getLevel(int l);
+  /*! Returns the pixel x,y using bilinear interpolation.
+   *  \param x
+   *    the abscissa specified in the finest level coordinate system
+   *  \param y
+   *    the ordinate specified in the finest level coordinate system
+   *  \param level
+   *    the level from which we want the pixel to be evaluated
+   */
+  virtual float pixel(int x, int y, int level=0);
+  /*! Returns the width of the level-th level image */
+  virtual int width(int level=0);
+  /*! Returns the height of the level-th level image */
+  virtual int height(int level=0);
+  /*! Returns the number of levels in the pyramid */
+  inline int getNumberOfLevels() const { return _levels.size();}
+}; 
+
+class LIB_IMAGE_EXPORT GaussianPyramid : public ImagePyramid
+{
+protected:
+  float _sigma;
+public:
+  GaussianPyramid(float iSigma=1.f) : ImagePyramid() {_sigma=iSigma;}
+  GaussianPyramid(const GrayImage& level0, unsigned nbLevels, float iSigma=1.f);
+  GaussianPyramid(GrayImage* level0, unsigned nbLevels, float iSigma=1.f);
+  GaussianPyramid(const GaussianPyramid& iBrother);
+  virtual ~GaussianPyramid(){}
+
+  virtual void BuildPyramid(const GrayImage& level0, unsigned nbLevels);
+  virtual void BuildPyramid(GrayImage* level0, unsigned nbLevels);
+  /* accessors */
+  inline float getSigma() const {return _sigma;}
+  /* modifiers */
+
+};
+#endif // IMAGEPYRAMID_H
diff --git a/source/blender/freestyle/intern/image/image.pro b/source/blender/freestyle/intern/image/image.pro
new file mode 100755
index 00000000000..133b6cf4f35
--- /dev/null
+++ b/source/blender/freestyle/intern/image/image.pro
@@ -0,0 +1,66 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_IMAGE}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES   *= MAKE_LIB_IMAGE_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../system
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/intern/image/src.pri b/source/blender/freestyle/intern/image/src.pri
new file mode 100755
index 00000000000..c047929b49f
--- /dev/null
+++ b/source/blender/freestyle/intern/image/src.pri
@@ -0,0 +1,13 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+IMAGE_DIR = ../image
+
+SOURCES *= $${IMAGE_DIR}/GaussianFilter.cpp \
+           $${IMAGE_DIR}/ImagePyramid.cpp
+
+HEADERS *= $${IMAGE_DIR}/Image.h \
+           $${IMAGE_DIR}/GaussianFilter.h \
+           $${IMAGE_DIR}/ImagePyramid.h
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate0D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate0D.cpp
new file mode 100644
index 00000000000..67358c65bbf
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate0D.cpp
@@ -0,0 +1,171 @@
+#include "BinaryPredicate0D.h"
+
+#include "Convert.h"
+#include "Interface0D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for BinaryPredicate0D instance  -----------*/
+static int BinaryPredicate0D___init__(BPy_BinaryPredicate0D *self, PyObject *args, PyObject *kwds);
+static void BinaryPredicate0D___dealloc__(BPy_BinaryPredicate0D *self);
+static PyObject * BinaryPredicate0D___repr__(BPy_BinaryPredicate0D *self);
+
+static PyObject * BinaryPredicate0D_getName( BPy_BinaryPredicate0D *self, PyObject *args);
+static PyObject * BinaryPredicate0D___call__( BPy_BinaryPredicate0D *self, PyObject *args);
+
+/*----------------------BinaryPredicate0D instance definitions ----------------------------*/
+static PyMethodDef BPy_BinaryPredicate0D_methods[] = {
+	{"getName", ( PyCFunction ) BinaryPredicate0D_getName, METH_NOARGS, "（ ）Returns the string of the name of the binary predicate."},
+	{"__call__", ( PyCFunction ) BinaryPredicate0D___call__, METH_VARARGS, "BinaryPredicate0D（Interface0D, Interface0D ）. Must be overloaded by inherited classes. It evaluates a relation between two Interface0D." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_BinaryPredicate0D type definition ------------------------------*/
+
+PyTypeObject BinaryPredicate0D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"BinaryPredicate0D",				/* tp_name */
+	sizeof( BPy_BinaryPredicate0D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)BinaryPredicate0D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)BinaryPredicate0D___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_BinaryPredicate0D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)BinaryPredicate0D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 BinaryPredicate0D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &BinaryPredicate0D_Type ) < 0 )
+		return;
+
+	Py_INCREF( &BinaryPredicate0D_Type );
+	PyModule_AddObject(module, "BinaryPredicate0D", (PyObject *)&BinaryPredicate0D_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int BinaryPredicate0D___init__(BPy_BinaryPredicate0D *self, PyObject *args, PyObject *kwds)
+{
+	self->bp0D = new BinaryPredicate0D();
+	return 0;
+}
+
+void BinaryPredicate0D___dealloc__(BPy_BinaryPredicate0D* self)
+{
+	delete self->bp0D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+
+PyObject * BinaryPredicate0D___repr__(BPy_BinaryPredicate0D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->bp0D->getName().c_str(), self->bp0D );
+}
+
+
+PyObject * BinaryPredicate0D_getName( BPy_BinaryPredicate0D *self, PyObject *args)
+{
+	return PyString_FromString( self->bp0D->getName().c_str() );
+}
+
+PyObject * BinaryPredicate0D___call__( BPy_BinaryPredicate0D *self, PyObject *args)
+{
+	BPy_Interface0D *obj1, *obj2;
+	bool b;
+
+	if( !PyArg_ParseTuple(args,(char *)"OO", &obj1, &obj2) ) {
+		cout << "ERROR: BinaryPredicate0D___call__ " << endl;		
+		return NULL;
+	}
+	
+	b = self->bp0D->operator()( *(obj1->if0D) , *(obj2->if0D) );
+	return PyBool_from_bool( b );
+
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate0D.h b/source/blender/freestyle/intern/python/BinaryPredicate0D.h
new file mode 100644
index 00000000000..dd192877675
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate0D.h
@@ -0,0 +1,36 @@
+#ifndef FREESTYLE_PYTHON_BINARYPREDICATE0D_H
+#define FREESTYLE_PYTHON_BINARYPREDICATE0D_H
+
+#include "../stroke/Predicates0D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject BinaryPredicate0D_Type;
+
+#define BPy_BinaryPredicate0D_Check(v)	(( (PyObject *) v)->ob_type == &BinaryPredicate0D_Type)
+
+/*---------------------------Python BPy_BinaryPredicate0D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	BinaryPredicate0D *bp0D;
+} BPy_BinaryPredicate0D;
+
+/*---------------------------Python BPy_BinaryPredicate0D visible prototypes-----------*/
+
+PyMODINIT_FUNC BinaryPredicate0D_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* FREESTYLE_PYTHON_BINARYPREDICATE0D_H */
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D.cpp
new file mode 100644
index 00000000000..bf2772ecdcc
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D.cpp
@@ -0,0 +1,168 @@
+#include "BinaryPredicate1D.h"
+
+#include "Convert.h"
+#include "Interface1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for BinaryPredicate1D instance  -----------*/
+static int BinaryPredicate1D___init__(BPy_BinaryPredicate1D *self, PyObject *args, PyObject *kwds);
+static void BinaryPredicate1D___dealloc__(BPy_BinaryPredicate1D *self);
+static PyObject * BinaryPredicate1D___repr__(BPy_BinaryPredicate1D *self);
+
+static PyObject * BinaryPredicate1D_getName( BPy_BinaryPredicate1D *self, PyObject *args);
+static PyObject * BinaryPredicate1D___call__( BPy_BinaryPredicate1D *self, PyObject *args);
+
+/*----------------------BinaryPredicate1D instance definitions ----------------------------*/
+static PyMethodDef BPy_BinaryPredicate1D_methods[] = {
+	{"getName", ( PyCFunction ) BinaryPredicate1D_getName, METH_NOARGS, "（ ）Returns the string of the name of the binary predicate."},
+	{"__call__", ( PyCFunction ) BinaryPredicate1D___call__, METH_VARARGS, "BinaryPredicate1D（Interface1D, Interface1D ）. Must be overloaded by inherited classes. It evaluates a relation between two Interface1D." },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_BinaryPredicate1D type definition ------------------------------*/
+PyTypeObject BinaryPredicate1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,									/* ob_size */
+	"BinaryPredicate1D",				/* tp_name */
+	sizeof( BPy_BinaryPredicate1D ),	/* tp_basicsize */
+	0,									/* tp_itemsize */
+	
+	/* methods */
+	(destructor)BinaryPredicate1D___dealloc__,		/* tp_dealloc */
+	NULL,                       					/* printfunc tp_print; */
+	NULL,                       					/* getattrfunc tp_getattr; */
+	NULL,                       					/* setattrfunc tp_setattr; */
+	NULL,											/* tp_compare */
+	(reprfunc)BinaryPredicate1D___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_BinaryPredicate1D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,							/*  struct PyMemberDef *tp_members; */
+	NULL,							/*  struct PyGetSetDef *tp_getset; */
+	NULL,							/*  struct _typeobject *tp_base; */
+	NULL,                       	/* PyObject *tp_dict; */
+	NULL,                       	/* descrgetfunc tp_descr_get; */
+	NULL,                       	/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)BinaryPredicate1D___init__,                       	/* initproc tp_init; */
+	NULL,                       	/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 BinaryPredicate1D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &BinaryPredicate1D_Type ) < 0 )
+		return;
+
+	Py_INCREF( &BinaryPredicate1D_Type );
+	PyModule_AddObject(module, "BinaryPredicate1D", (PyObject *)&BinaryPredicate1D_Type);
+}
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int BinaryPredicate1D___init__(BPy_BinaryPredicate1D *self, PyObject *args, PyObject *kwds)
+{
+	self->bp1D = new BinaryPredicate1D();
+	return 0;
+}
+
+void BinaryPredicate1D___dealloc__(BPy_BinaryPredicate1D* self)
+{
+	delete self->bp1D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+PyObject * BinaryPredicate1D___repr__(BPy_BinaryPredicate1D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->bp1D->getName().c_str(), self->bp1D );
+}
+
+PyObject *BinaryPredicate1D_getName( BPy_BinaryPredicate1D *self, PyObject *args)
+{
+	return PyString_FromString( self->bp1D->getName().c_str() );
+}
+
+PyObject *BinaryPredicate1D___call__( BPy_BinaryPredicate1D *self, PyObject *args)
+{
+	BPy_Interface1D *obj1, *obj2;
+	bool b;
+	
+	if( !PyArg_ParseTuple(args,(char *)"OO", &obj1, &obj2) ) {
+		cout << "ERROR: BinaryPredicate1D___call__ " << endl;		
+		return NULL;
+	}
+	
+	b = self->bp1D->operator()( *(obj1->if1D) , *(obj2->if1D) );
+	return PyBool_from_bool( b );
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D.h b/source/blender/freestyle/intern/python/BinaryPredicate1D.h
new file mode 100644
index 00000000000..035e2b6cb17
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D.h
@@ -0,0 +1,35 @@
+#ifndef FREESTYLE_PYTHON_BINARYPREDICATE1D_H
+#define FREESTYLE_PYTHON_BINARYPREDICATE1D_H
+
+#include "../stroke/Predicates1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject BinaryPredicate1D_Type;
+
+#define BPy_BinaryPredicate1D_Check(v)	(( (PyObject *) v)->ob_type == &BinaryPredicate1D_Type)
+
+/*---------------------------Python BPy_BinaryPredicate1D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	BinaryPredicate1D *bp1D;
+} BPy_BinaryPredicate1D;
+
+/*---------------------------Python BPy_BinaryPredicate1D visible prototypes-----------*/
+
+PyMODINIT_FUNC BinaryPredicate1D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* FREESTYLE_PYTHON_BINARYPREDICATE1D_H */
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D/FalseBP1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D/FalseBP1D.cpp
new file mode 100644
index 00000000000..1f1a1ec840b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D/FalseBP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_FalseBP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FalseBP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_FalseBP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_FalseBP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D/Length2DBP1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D/Length2DBP1D.cpp
new file mode 100644
index 00000000000..402e59c3f29
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D/Length2DBP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_Length2DBP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Length2DBP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_Length2DBP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Length2DBP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D/SameShapeIdBP1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D/SameShapeIdBP1D.cpp
new file mode 100644
index 00000000000..d980750bb33
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D/SameShapeIdBP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_SameShapeIdBP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SameShapeIdBP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_SameShapeIdBP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_SameShapeIdBP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D/TrueBP1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D/TrueBP1D.cpp
new file mode 100644
index 00000000000..2afd2e163ea
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D/TrueBP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_TrueBP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TrueBP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_TrueBP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TrueBP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/BinaryPredicate1D/ViewMapGradientNormBP1D.cpp b/source/blender/freestyle/intern/python/BinaryPredicate1D/ViewMapGradientNormBP1D.cpp
new file mode 100644
index 00000000000..873acd93149
--- /dev/null
+++ b/source/blender/freestyle/intern/python/BinaryPredicate1D/ViewMapGradientNormBP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ViewMapGradientNormBP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMapGradientNormBP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ViewMapGradientNormBP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Convert.cpp b/source/blender/freestyle/intern/python/Convert.cpp
new file mode 100644
index 00000000000..410afe99d63
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Convert.cpp
@@ -0,0 +1,109 @@
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+
+PyObject * PyBool_from_bool( bool b ){
+	return PyBool_FromLong( b ? 1 : 0);
+}
+
+
+PyObject * Vector_from_Vec2f( Vec2f& vec ) {
+	float vec_data[2]; // because vec->_coord is protected
+
+	vec_data[0] = vec.x();		vec_data[1] = vec.y();
+	return newVectorObject( vec_data, 2, Py_NEW);
+}
+
+PyObject * Vector_from_Vec3f( Vec3f& vec ) {
+	float vec_data[3]; // because vec->_coord is protected
+	
+	vec_data[0] = vec.x();		vec_data[1] = vec.y(); 		vec_data[2] = vec.z(); 
+	return newVectorObject( vec_data, 3, Py_NEW);
+}
+
+PyObject * Vector_from_Vec3r( Vec3r& vec ) {
+	float vec_data[3]; // because vec->_coord is protected
+	
+	vec_data[0] = vec.x();		vec_data[1] = vec.y(); 		vec_data[2] = vec.z(); 
+	return newVectorObject( vec_data, 3, Py_NEW);
+}
+
+PyObject * BPy_Id_from_Id( Id& id ) {
+	PyObject *py_id = Id_Type.tp_new( &Id_Type, 0, 0 );
+	((BPy_Id *) py_id)->id = new Id( id.getFirst(), id.getSecond() );
+
+	return py_id;
+}
+
+PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D ) {
+	PyObject *py_if0D =  Interface0D_Type.tp_new( &Interface0D_Type, 0, 0 );
+	((BPy_Interface0D *) py_if0D)->if0D = &if0D;
+
+	return py_if0D;
+}
+
+PyObject * BPy_SVertex_from_SVertex( SVertex& sv ) {
+	PyObject *py_sv = SVertex_Type.tp_new( &SVertex_Type, 0, 0 );
+	((BPy_SVertex *) py_sv)->sv = new SVertex( sv );
+	((BPy_SVertex *) py_sv)->py_if0D.if0D = ((BPy_SVertex *) py_sv)->sv;
+
+	return py_sv;
+}
+
+PyObject * BPy_FEdge_from_FEdge( FEdge& fe ) {
+	PyObject *py_fe = FEdge_Type.tp_new( &FEdge_Type, 0, 0 );
+	((BPy_FEdge *) py_fe)->fe = new FEdge( fe );
+	((BPy_FEdge *) py_fe)->py_if1D.if1D = ((BPy_FEdge *) py_fe)->fe;
+
+	return py_fe;
+}
+
+PyObject * BPy_Nature_from_Nature( unsigned short n ) {
+	PyObject *py_n =  Nature_Type.tp_new( &Nature_Type, 0, 0 );
+
+	PyObject *args = PyTuple_New(1);
+	PyTuple_SetItem( args, 0, PyInt_FromLong(n) );
+	Nature_Type.tp_init( py_n, args, 0 );
+	Py_DECREF(args);
+
+	return py_n;
+}
+
+PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa ) {
+	PyObject *py_sa = StrokeAttribute_Type.tp_new( &StrokeAttribute_Type, 0, 0 );
+	((BPy_StrokeAttribute *) py_sa)->sa = new StrokeAttribute( sa );
+
+	return py_sa;	
+}
+
+PyObject * BPy_MediumType_from_MediumType( unsigned short n ) {
+	PyObject *py_mt =  MediumType_Type.tp_new( &MediumType_Type, 0, 0 );
+
+	PyObject *args = PyTuple_New(1);
+	PyTuple_SetItem( args, 0, PyInt_FromLong(n) );
+	MediumType_Type.tp_init( py_mt, args, 0 );
+	Py_DECREF(args);
+
+	return py_mt;
+}
+
+PyObject * BPy_StrokeVertex_from_StrokeVertex( StrokeVertex& sv ) {
+	PyObject *py_sv = StrokeVertex_Type.tp_new( &StrokeVertex_Type, 0, 0 );
+	((BPy_StrokeVertex *) py_sv)->sv = new StrokeVertex( sv );
+	((BPy_StrokeVertex *) py_sv)->py_cp.cp = ((BPy_StrokeVertex *) py_sv)->sv;
+	((BPy_StrokeVertex *) py_sv)->py_cp.py_if0D.if0D = ((BPy_StrokeVertex *) py_sv)->sv;
+
+	return py_sv;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/python/Convert.h b/source/blender/freestyle/intern/python/Convert.h
new file mode 100644
index 00000000000..3caf8bf67f9
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Convert.h
@@ -0,0 +1,49 @@
+#ifndef FREESTYLE_PYTHON_CONVERT_H
+#define FREESTYLE_PYTHON_CONVERT_H
+
+#include "../geometry/Geom.h"
+using namespace Geometry;
+
+#include "Id.h"
+#include "IntegrationType.h"
+#include "Interface0D.h"
+#include "Interface0D/CurvePoint/StrokeVertex.h"
+#include "Interface0D/SVertex.h"
+#include "Interface1D/FEdge.h"
+#include "Nature.h"
+#include "MediumType.h"
+#include "StrokeAttribute.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+#include "api2_2x/vector.h"
+#include "api2_2x/gen_utils.h"
+
+PyObject * PyBool_from_bool( bool b );
+
+PyObject * Vector_from_Vec2f( Vec2f& v );
+PyObject * Vector_from_Vec3f( Vec3f& v );
+PyObject * Vector_from_Vec3r( Vec3r& v );
+
+PyObject * BPy_FEdge_from_FEdge( FEdge& fe );
+PyObject * BPy_Id_from_Id( Id& id );
+PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
+PyObject * BPy_Nature_from_Nature( unsigned short n );
+PyObject * BPy_MediumType_from_MediumType( unsigned short n );
+PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa );
+PyObject * BPy_StrokeVertex_from_StrokeVertex( StrokeVertex& sv );
+PyObject * BPy_SVertex_from_SVertex( SVertex& sv );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* FREESTYLE_PYTHON_CONVERT_H */
diff --git a/source/blender/freestyle/intern/python/CurvePointIterator.cpp b/source/blender/freestyle/intern/python/CurvePointIterator.cpp
new file mode 100644
index 00000000000..57dc86ea5e4
--- /dev/null
+++ b/source/blender/freestyle/intern/python/CurvePointIterator.cpp
@@ -0,0 +1,284 @@
+ PyObject *_wrap_CurvePointIterator__CurvilinearLength_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__CurvilinearLength_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__step_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__step_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___A_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___A_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___B_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___B_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__begin_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__begin_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__end_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__end_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__n_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__n_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__currentn_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__currentn_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__t_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__t_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__Point_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__Point_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__CurveLength_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator__CurveLength_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_CurvePointIterator__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_CurvePointIterator__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_CurvePointIterator__SWIG_2(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_CurvePointIterator(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_CurvePointIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_copy(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_CastToInterface0DIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___eq__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getObject(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator___deref__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_isBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_isEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getPoint3D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getProjectedX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getProjectedY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getProjectedZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getPoint2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getFEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_getNature(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_castToSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_castToViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_castToNonTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_castToTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_A(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_B(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_t2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_SetA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_SetB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_SetT2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_fedge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_point2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_point3d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_normal(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occluders_begin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occluders_end(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occluders_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occluders_size(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occludee(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occluded_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_occludee_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_z_discontinuity(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_curvatureFredo(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurvePointIterator_directionFredo(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/EdgeModifier.cpp b/source/blender/freestyle/intern/python/EdgeModifier.cpp
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/EdgeModifier.cpp
diff --git a/source/blender/freestyle/intern/python/EdgeModifier/TimestampModifier.cpp b/source/blender/freestyle/intern/python/EdgeModifier/TimestampModifier.cpp
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/EdgeModifier/TimestampModifier.cpp
diff --git a/source/blender/freestyle/intern/python/Freestyle.cpp b/source/blender/freestyle/intern/python/Freestyle.cpp
new file mode 100644
index 00000000000..2f93f1f8a74
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Freestyle.cpp
@@ -0,0 +1,153 @@
+#include "Freestyle.h"
+
+#include "BinaryPredicate0D.h"
+#include "BinaryPredicate1D.h"
+#include "Id.h"
+#include "IntegrationType.h"
+#include "Interface0D.h"
+#include "Interface0D/CurvePoint.h"
+#include "Interface1D.h"
+#include "Nature.h"
+#include "StrokeAttribute.h"
+#include "StrokeShader.h"
+#include "UnaryFunction0D.h"
+#include "UnaryFunction1D.h"
+#include "UnaryPredicate0D.h"
+#include "UnaryPredicate1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+
+/*-----------------------Python API function prototypes for the Freestyle module--*/
+//static PyObject *Freestyle_testOutput( BPy_Freestyle * self );
+/*-----------------------Freestyle module doc strings-----------------------------*/
+static char M_Freestyle_doc[] = "The Blender.Freestyle submodule";
+/*----------------------Freestyle module method def----------------------------*/
+struct PyMethodDef M_Freestyle_methods[] = {
+//	{"testOutput", ( PyCFunction ) Freestyle_testOutput, METH_NOARGS, "() - Return Curve Data name"},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Freestyle method def------------------------------*/
+
+PyTypeObject Freestyle_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Freestyle",				/* tp_name */
+	sizeof( BPy_Freestyle ),	/* 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, 		/* 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; */
+	NULL,                       /* struct _typeobject *tp_base; */
+	NULL,                       /* PyObject *tp_dict; */
+	NULL,                       /* descrgetfunc tp_descr_get; */
+	NULL,                       /* descrsetfunc tp_descr_set; */
+	0,                          /* long tp_dictoffset; */
+	NULL,                       /* 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--------------------------------
+PyObject *Freestyle_Init( void )
+{
+	PyObject *module;
+	
+	if( PyType_Ready( &Freestyle_Type ) < 0 )
+		return NULL;
+	
+	// initialize modules
+	module = Py_InitModule3( "Blender.Freestyle", M_Freestyle_methods, M_Freestyle_doc );
+	
+	// attach its classes (adding the object types to the module)
+	BinaryPredicate0D_Init( module );
+	BinaryPredicate1D_Init( module );
+	Id_Init( module );
+	IntegrationType_Init( module );
+	Interface0D_Init( module );
+	Interface1D_Init( module );
+	Nature_Init( module );
+	StrokeAttribute_Init( module );
+	StrokeShader_Init( module );
+	UnaryFunction0D_Init( module );
+	UnaryFunction1D_Init( module );
+	UnaryPredicate0D_Init( module );
+	UnaryPredicate1D_Init( module );
+	
+	return module;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/python/Freestyle.h b/source/blender/freestyle/intern/python/Freestyle.h
new file mode 100644
index 00000000000..9cdef4df2d2
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Freestyle.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_FREESTYLE_H
+#define FREESTYLE_PYTHON_FREESTYLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Freestyle_Type;
+
+#define BPy_Freestyle_Check(v)	(( (PyObject *) v)->ob_type == &Freestyle_Type)
+
+/*---------------------------Python BPy_Freestyle structure definition----------*/
+typedef struct {
+	PyObject_HEAD 
+} BPy_Freestyle;
+
+/*---------------------------Python BPy_Freestyle visible prototypes-----------*/
+
+PyObject *Freestyle_Init( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_FREESTYLE_H */
diff --git a/source/blender/freestyle/intern/python/Id.cpp b/source/blender/freestyle/intern/python/Id.cpp
new file mode 100644
index 00000000000..4f2964d8060
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Id.cpp
@@ -0,0 +1,222 @@
+#include "Id.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Id instance  -----------*/
+static int Id___init__(BPy_Id *self, PyObject *args, PyObject *kwds);
+static void Id___dealloc__(BPy_Id *self);
+static PyObject * Id___repr__(BPy_Id* self);
+static PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid);
+
+static PyObject * Id_getFirst( BPy_Id *self );
+static PyObject * Id_getSecond( BPy_Id *self);
+static PyObject * Id_setFirst( BPy_Id *self , PyObject *args);
+static PyObject * Id_setSecond( BPy_Id *self , PyObject *args);
+
+/*----------------------Id instance definitions ----------------------------*/
+static PyMethodDef BPy_Id_methods[] = {
+	{"getFirst", ( PyCFunction ) Id_getFirst, METH_NOARGS, "Returns the first Id number"},
+	{"getSecond", ( PyCFunction ) Id_getSecond, METH_NOARGS, "Returns the second Id number" },
+	{"setFirst", ( PyCFunction ) Id_setFirst, METH_VARARGS, "Sets the first number constituing the Id" },
+	{"setSecond", ( PyCFunction ) Id_setSecond, METH_VARARGS, "Sets the second number constituing the Id" },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Id type definition ------------------------------*/
+
+PyTypeObject Id_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Id",						/* tp_name */
+	sizeof( BPy_Id ),			/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)Id___dealloc__,	/* tp_dealloc */
+	NULL,                       /* printfunc tp_print; */
+	NULL,                       /* getattrfunc tp_getattr; */
+	NULL,                       /* setattrfunc tp_setattr; */
+	NULL,						/* tp_compare */
+	(reprfunc)Id___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 ***/
+	(richcmpfunc)Id_RichCompare,                   /* 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_Id_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Id___init__,           /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,						/* 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 Id_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &Id_Type ) < 0 )
+		return;
+
+	Py_INCREF( &Id_Type );
+	PyModule_AddObject(module, "Id", (PyObject *)&Id_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Id___init__(BPy_Id *self, PyObject *args, PyObject *kwds)
+{
+    int first = 0, second = 0;
+    static char *kwlist[] = {"first", "second", NULL};
+
+    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, &first, &second) )
+        return -1;
+
+	self->id = new Id( first, second );
+
+    return 0;
+}
+
+void Id___dealloc__(BPy_Id* self)
+{
+	delete self->id;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+PyObject * Id___repr__(BPy_Id* self)
+{
+    return PyString_FromFormat("[ first: %i, second: %i ](BPy_Id)", self->id->getFirst(), self->id->getSecond() );
+}
+
+PyObject *Id_getFirst( BPy_Id *self ) {
+	return PyInt_FromLong( self->id->getFirst() );
+}
+
+
+PyObject *Id_getSecond( BPy_Id *self) {
+	return PyInt_FromLong( self->id->getSecond() );
+}
+
+
+PyObject *Id_setFirst( BPy_Id *self , PyObject *args) {
+	unsigned int i;
+
+	if( !PyArg_ParseTuple(args, (char *)"i", &i) ) {
+		cout << "ERROR: Id_setFirst" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->id->setFirst( i );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *Id_setSecond( BPy_Id *self , PyObject *args) {
+	unsigned int i;
+
+	if( !PyArg_ParseTuple(args, (char *)"i", &i) ) {
+		cout << "ERROR: Id_setSecond" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->id->setSecond( i );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid) {
+	switch(opid){
+		case Py_LT:
+			return PyBool_from_bool( o1->id->operator<(*(o2->id)) );
+			break;
+		case Py_LE:
+			return PyBool_from_bool( o1->id->operator<(*(o2->id)) || o1->id->operator<(*(o2->id)) );
+			break;
+		case Py_EQ:
+			return PyBool_from_bool( o1->id->operator==(*(o2->id)) );
+			break;
+		case Py_NE:
+			return PyBool_from_bool( o1->id->operator!=(*(o2->id)) );
+			break;
+		case Py_GT:
+			return PyBool_from_bool(!( o1->id->operator<(*(o2->id)) || o1->id->operator<(*(o2->id)) ));
+			break;
+		case Py_GE:
+			return PyBool_from_bool(!( o1->id->operator<(*(o2->id)) ));
+			break;
+	}
+	
+	Py_RETURN_NONE;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/python/Id.h b/source/blender/freestyle/intern/python/Id.h
new file mode 100644
index 00000000000..d5e90a0a3e5
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Id.h
@@ -0,0 +1,37 @@
+#ifndef FREESTYLE_PYTHON_ID_H
+#define FREESTYLE_PYTHON_ID_H
+
+#include <iostream>
+using namespace std;
+
+#include "../system/Id.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Id_Type;
+
+#define BPy_Id_Check(v)	(( (PyObject *) v)->ob_type == &Id_Type)
+
+/*---------------------------Python BPy_Id structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	Id *id;
+} BPy_Id;
+
+/*---------------------------Python BPy_Id visible prototypes-----------*/
+
+PyMODINIT_FUNC Id_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_ID_H */
diff --git a/source/blender/freestyle/intern/python/IntegrationType.cpp b/source/blender/freestyle/intern/python/IntegrationType.cpp
new file mode 100644
index 00000000000..ff6bd3d4794
--- /dev/null
+++ b/source/blender/freestyle/intern/python/IntegrationType.cpp
@@ -0,0 +1,153 @@
+#include "IntegrationType.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for IntegrationType instance  -----------*/
+static int IntegrationType___init__(BPy_IntegrationType *self, PyObject *args, PyObject *kwds);
+
+/*----------------------IntegrationType instance definitions ----------------------------*/
+static PyMethodDef BPy_IntegrationType_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_IntegrationType type definition ------------------------------*/
+
+PyTypeObject IntegrationType_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"IntegrationType",				/* tp_name */
+	sizeof( BPy_IntegrationType ),	/* 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 ***/
+	BPy_IntegrationType_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&PyInt_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)IntegrationType___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,			/* 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 IntegrationType_Init( PyObject *module )
+{	
+	PyObject *tmp;
+	
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &IntegrationType_Type ) < 0 )
+		return;
+	Py_INCREF( &IntegrationType_Type );
+	PyModule_AddObject(module, "IntegrationType", (PyObject *)&IntegrationType_Type);
+
+	tmp = PyInt_FromLong( MEAN );
+	PyDict_SetItemString( IntegrationType_Type.tp_dict, "MEAN", tmp);
+	Py_DECREF(tmp);
+	
+	tmp = PyInt_FromLong( MIN );
+	PyDict_SetItemString( IntegrationType_Type.tp_dict, "MIN", tmp);
+	Py_DECREF(tmp);
+	
+	tmp = PyInt_FromLong( MAX );
+	PyDict_SetItemString( IntegrationType_Type.tp_dict, "MAX", tmp);
+	Py_DECREF(tmp);
+	
+	tmp = PyInt_FromLong( FIRST );
+	PyDict_SetItemString( IntegrationType_Type.tp_dict, "FIRST", tmp);
+	Py_DECREF(tmp);
+	
+	tmp = PyInt_FromLong( LAST );
+	PyDict_SetItemString( IntegrationType_Type.tp_dict, "LAST", tmp);
+	Py_DECREF(tmp);
+	
+	
+}
+
+int IntegrationType___init__(BPy_IntegrationType *self, PyObject *args, PyObject *kwds)
+{
+    if (PyInt_Type.tp_init((PyObject *)self, args, kwds) < 0)
+        return -1;
+	
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/IntegrationType.h b/source/blender/freestyle/intern/python/IntegrationType.h
new file mode 100644
index 00000000000..ab212ac6560
--- /dev/null
+++ b/source/blender/freestyle/intern/python/IntegrationType.h
@@ -0,0 +1,33 @@
+#ifndef FREESTYLE_PYTHON_INTEGRATIONTYPE_H
+#define FREESTYLE_PYTHON_INTEGRATIONTYPE_H
+
+#include "../view_map/Interface1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject IntegrationType_Type;
+
+#define BPy_IntegrationType_Check(v)	(( (PyObject *) v)->ob_type == &IntegrationType_Type)
+
+/*---------------------------Python BPy_IntegrationType structure definition----------*/
+typedef struct {
+	PyIntObject i;
+} BPy_IntegrationType;
+
+/*---------------------------Python BPy_IntegrationType visible prototypes-----------*/
+
+PyMODINIT_FUNC IntegrationType_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_INTEGRATIONTYPE_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D.cpp b/source/blender/freestyle/intern/python/Interface0D.cpp
new file mode 100644
index 00000000000..4c3e0af0edb
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D.cpp
@@ -0,0 +1,267 @@
+#include "Interface0D.h"
+
+#include "Convert.h"
+#include "Interface0D/CurvePoint.h"
+#include "Interface0D/CurvePoint/StrokeVertex.h"
+#include "Interface0D/SVertex.h"
+#include "Interface0D/ViewVertex.h"
+#include "Interface1D/FEdge.h"
+#include "Nature.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Interface0D instance  -----------*/
+static int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds);
+static void Interface0D___dealloc__(BPy_Interface0D *self);
+static PyObject * Interface0D___repr__(BPy_Interface0D *self);
+
+static PyObject *Interface0D_getExactTypeName( BPy_Interface0D *self );
+static PyObject *Interface0D_getX( BPy_Interface0D *self );
+static PyObject *Interface0D_getY( BPy_Interface0D *self );
+static PyObject *Interface0D_getZ( BPy_Interface0D *self );
+static PyObject *Interface0D_getPoint3D( BPy_Interface0D *self );
+static PyObject *Interface0D_getProjectedX( BPy_Interface0D *self );
+static PyObject *Interface0D_getProjectedY( BPy_Interface0D *self );
+static PyObject *Interface0D_getProjectedZ( BPy_Interface0D *self );
+static PyObject *Interface0D_getPoint2D( BPy_Interface0D *self );
+static PyObject *Interface0D_getFEdge( BPy_Interface0D *self, PyObject *args );
+static PyObject *Interface0D_getId( BPy_Interface0D *self );
+static PyObject *Interface0D_getNature( BPy_Interface0D *self ); 
+
+/*----------------------Interface0D instance definitions ----------------------------*/
+static PyMethodDef BPy_Interface0D_methods[] = {
+	{"getExactTypeName", ( PyCFunction ) Interface0D_getExactTypeName, METH_NOARGS, "（ ）Returns the string of the name of the interface."},
+	{"getX", ( PyCFunction ) Interface0D_getX, METH_NOARGS, "（ ）Returns the 3D x coordinate of the point. "},
+	{"getY", ( PyCFunction ) Interface0D_getY, METH_NOARGS, "（ ）Returns the 3D y coordinate of the point. "},
+	{"getZ", ( PyCFunction ) Interface0D_getZ, METH_NOARGS, "（ ）Returns the 3D z coordinate of the point. "},
+	{"getPoint3D", ( PyCFunction ) Interface0D_getPoint3D, METH_NOARGS, "() Returns the 3D point."},
+	{"getProjectedX", ( PyCFunction ) Interface0D_getProjectedX, METH_NOARGS, "() Returns the 2D x coordinate of the point."},
+	{"getProjectedY", ( PyCFunction ) Interface0D_getProjectedY, METH_NOARGS, "() Returns the 2D y coordinate of the point."},
+	{"getProjectedZ", ( PyCFunction ) Interface0D_getProjectedZ, METH_NOARGS, "() Returns the 2D z coordinate of the point."},
+	{"getPoint2D", ( PyCFunction ) Interface0D_getPoint2D, METH_NOARGS, "() Returns the 2D point."},
+	{"getFEdge", ( PyCFunction ) Interface0D_getFEdge, METH_VARARGS, "(Interface0D i) Returns the FEdge that lies between this Interface0D and the Interface0D given as argument."},
+	{"getId", ( PyCFunction ) Interface0D_getId, METH_NOARGS, "() Returns the Id of the point."},
+	{"getNature", ( PyCFunction ) Interface0D_getNature, METH_NOARGS, "() Returns the nature of the point."},	
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Interface0D type definition ------------------------------*/
+
+PyTypeObject Interface0D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Interface0D",				/* tp_name */
+	sizeof( BPy_Interface0D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)Interface0D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)Interface0D___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_Interface0D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Interface0D___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 Interface0D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &Interface0D_Type ) < 0 )
+		return;
+	Py_INCREF( &Interface0D_Type );
+	PyModule_AddObject(module, "Interface0D", (PyObject *)&Interface0D_Type);
+	
+	if( PyType_Ready( &CurvePoint_Type ) < 0 )
+		return;
+	Py_INCREF( &CurvePoint_Type );
+	PyModule_AddObject(module, "CurvePoint", (PyObject *)&CurvePoint_Type);
+	
+	if( PyType_Ready( &SVertex_Type ) < 0 )
+		return;
+	Py_INCREF( &SVertex_Type );
+	PyModule_AddObject(module, "SVertex", (PyObject *)&SVertex_Type);	
+	
+	if( PyType_Ready( &ViewVertex_Type ) < 0 )
+		return;
+	Py_INCREF( &ViewVertex_Type );
+	PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type);
+	
+	if( PyType_Ready( &StrokeVertex_Type ) < 0 )
+		return;
+	Py_INCREF( &StrokeVertex_Type );
+	PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds)
+{
+	self->if0D = new Interface0D();
+	return 0;
+}
+
+void Interface0D___dealloc__(BPy_Interface0D* self)
+{
+	delete self->if0D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+PyObject * Interface0D___repr__(BPy_Interface0D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D );
+}
+
+PyObject *Interface0D_getExactTypeName( BPy_Interface0D *self ) {
+	return PyString_FromString( self->if0D->getExactTypeName().c_str() );	
+}
+
+
+PyObject *Interface0D_getX( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getX() );
+}
+
+
+PyObject *Interface0D_getY( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getY() );
+}
+
+
+PyObject *Interface0D_getZ( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getZ() );
+}
+
+
+PyObject *Interface0D_getPoint3D( BPy_Interface0D *self ) {
+	Vec3f v( self->if0D->getPoint3D() );
+	return Vector_from_Vec3f( v );
+}
+
+
+PyObject *Interface0D_getProjectedX( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getProjectedX() );
+}
+
+
+PyObject *Interface0D_getProjectedY( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getProjectedY() );
+}
+
+
+PyObject *Interface0D_getProjectedZ( BPy_Interface0D *self ) {
+	return PyFloat_FromDouble( self->if0D->getProjectedZ() );
+}
+
+
+PyObject *Interface0D_getPoint2D( BPy_Interface0D *self ) {
+	Vec2f v( self->if0D->getPoint2D() );
+	return Vector_from_Vec2f( v );
+}
+
+
+PyObject *Interface0D_getFEdge( BPy_Interface0D *self, PyObject *args ) {
+	PyObject *py_if0D;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_if0D) && BPy_Interface0D_Check(py_if0D) )) {
+		cout << "ERROR: Interface0D_getFEdge" << endl;
+		Py_RETURN_NONE;
+	}
+
+	FEdge *fe = self->if0D->getFEdge(*( ((BPy_Interface0D *) py_if0D)->if0D ));
+	if( fe )
+		return BPy_FEdge_from_FEdge( *fe );
+	
+	Py_RETURN_NONE;
+}
+
+
+PyObject *Interface0D_getId( BPy_Interface0D *self ) {
+	Id id( self->if0D->getId() );
+	return BPy_Id_from_Id( id );
+}
+
+
+PyObject *Interface0D_getNature( BPy_Interface0D *self ) {
+	return BPy_Nature_from_Nature( self->if0D->getNature() );
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/Interface0D.h b/source/blender/freestyle/intern/python/Interface0D.h
new file mode 100644
index 00000000000..aaecc6dad94
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_INTERFACE0D_H
+#define FREESTYLE_PYTHON_INTERFACE0D_H
+
+#include "../view_map/Interface0D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Interface0D_Type;
+
+#define BPy_Interface0D_Check(v)	(( (PyObject *) v)->ob_type == &Interface0D_Type)
+
+/*---------------------------Python BPy_Interface0D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	Interface0D *if0D;
+} BPy_Interface0D;
+
+/*---------------------------Python BPy_Interface0D visible prototypes-----------*/
+
+PyMODINIT_FUNC Interface0D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_INTERFACE0D_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint.cpp b/source/blender/freestyle/intern/python/Interface0D/CurvePoint.cpp
new file mode 100644
index 00000000000..e1cf63727e5
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint.cpp
@@ -0,0 +1,237 @@
+#include "CurvePoint.h"
+
+#include "../Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for CurvePoint instance  -----------*/
+static int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *kwds);
+static PyObject * CurvePoint___copy__( BPy_CurvePoint *self );
+static PyObject * CurvePoint_A( BPy_CurvePoint *self );
+static PyObject * CurvePoint_B( BPy_CurvePoint *self );
+static PyObject * CurvePoint_t2d( BPy_CurvePoint *self );
+static PyObject *CurvePoint_setA( BPy_CurvePoint *self , PyObject *args);
+static PyObject *CurvePoint_setB( BPy_CurvePoint *self , PyObject *args);
+static PyObject *CurvePoint_setT2d( BPy_CurvePoint *self , PyObject *args);
+static PyObject *CurvePoint_curvatureFredo( BPy_CurvePoint *self , PyObject *args);
+
+/*----------------------CurvePoint instance definitions ----------------------------*/
+static PyMethodDef BPy_CurvePoint_methods[] = {	
+	{"__copy__", ( PyCFunction ) CurvePoint___copy__, METH_NOARGS, "（ ）Cloning method."},
+	{"A", ( PyCFunction ) CurvePoint_A, METH_NOARGS, "（ ）Returns the first SVertex upon which the CurvePoint is built."},
+	{"B", ( PyCFunction ) CurvePoint_B, METH_NOARGS, "（ ）Returns the second SVertex upon which the CurvePoint is built."},
+	{"t2d", ( PyCFunction ) CurvePoint_t2d, METH_NOARGS, "（ ）Returns the interpolation parameter."},
+	{"setA", ( PyCFunction ) CurvePoint_setA, METH_VARARGS, "（SVertex sv ）Sets the first SVertex upon which to build the CurvePoint."},
+	{"setB", ( PyCFunction ) CurvePoint_setB, METH_VARARGS, "（SVertex sv ）Sets the second SVertex upon which to build the CurvePoint."},
+	{"setT2d", ( PyCFunction ) CurvePoint_setT2d, METH_VARARGS, "（ ）Sets the 2D interpolation parameter to use."},
+	{"curvatureFredo", ( PyCFunction ) CurvePoint_curvatureFredo, METH_NOARGS, "（ ）angle in radians."},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_CurvePoint type definition ------------------------------*/
+
+PyTypeObject CurvePoint_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"CurvePoint",				/* tp_name */
+	sizeof( BPy_CurvePoint ),	/* 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 ***/
+	BPy_CurvePoint_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&Interface0D_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)CurvePoint___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *kwds)
+{
+
+	PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0;
+
+    if (! PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3) )
+        return -1;
+
+	if( !obj1 && !obj2 && !obj3 ){
+		self->cp = new CurvePoint();
+	} else if( PyFloat_Check(obj3) ) {
+		if( BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
+			self->cp = new CurvePoint(  ((BPy_SVertex *) obj1)->sv,
+										((BPy_SVertex *) obj2)->sv,
+										PyFloat_AsDouble( obj3 ) );
+		} else if( BPy_CurvePoint_Check(obj1) && BPy_CurvePoint_Check(obj2) ) {
+			self->cp = new CurvePoint(  ((BPy_CurvePoint *) obj1)->cp,
+										((BPy_CurvePoint *) obj2)->cp,
+										PyFloat_AsDouble( obj3 ) );
+		} else {
+			return -1;	
+		}		
+	} else {
+		return -1;
+	}
+
+	self->py_if0D.if0D = self->cp;
+
+	return 0;
+}
+
+PyObject * CurvePoint___copy__( BPy_CurvePoint *self ) {
+	BPy_CurvePoint *py_cp;
+	
+	py_cp = (BPy_CurvePoint *) CurvePoint_Type.tp_new( &CurvePoint_Type, 0, 0 );
+	
+	py_cp->cp = new CurvePoint( *(self->cp) );
+	py_cp->py_if0D.if0D = py_cp->cp;
+
+	return (PyObject *) py_cp;
+}
+
+PyObject * CurvePoint_A( BPy_CurvePoint *self ) {
+	if( SVertex *A = self->cp->A() )
+		return BPy_SVertex_from_SVertex( *A );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * CurvePoint_B( BPy_CurvePoint *self ) {
+	if( SVertex *B = self->cp->B() )
+		return BPy_SVertex_from_SVertex( *B );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * CurvePoint_t2d( BPy_CurvePoint *self ) {
+	return PyFloat_FromDouble( self->cp->t2d() );
+}
+
+PyObject *CurvePoint_setA( BPy_CurvePoint *self , PyObject *args) {
+	PyObject *py_sv;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv)  )) {
+		cout << "ERROR: CurvePoint_setA" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->cp->setA( ((BPy_SVertex *) py_sv)->sv );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *CurvePoint_setB( BPy_CurvePoint *self , PyObject *args) {
+	PyObject *py_sv;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv)  )) {
+		cout << "ERROR: CurvePoint_setB" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->cp->setB( ((BPy_SVertex *) py_sv)->sv );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *CurvePoint_setT2d( BPy_CurvePoint *self , PyObject *args) {
+	float t;
+
+	if( !PyArg_ParseTuple(args, "f", &t) ) {
+		cout << "ERROR: CurvePoint_setT2d" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->cp->setT2d( t );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *CurvePoint_curvatureFredo( BPy_CurvePoint *self , PyObject *args) {
+	return PyFloat_FromDouble( self->cp->curvatureFredo() );
+}
+
+///bool 	operator== (const CurvePoint &b)
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint.h b/source/blender/freestyle/intern/python/Interface0D/CurvePoint.h
new file mode 100644
index 00000000000..e40f261504f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_CURVEPOINT_H
+#define FREESTYLE_PYTHON_CURVEPOINT_H
+
+#include "../Interface0D.h"
+#include "../../stroke/Curve.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject CurvePoint_Type;
+
+#define BPy_CurvePoint_Check(v)	(( (PyObject *) v)->ob_type == &CurvePoint_Type)
+
+/*---------------------------Python BPy_CurvePoint structure definition----------*/
+typedef struct {
+	BPy_Interface0D py_if0D;
+	CurvePoint *cp;
+} BPy_CurvePoint;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_CURVEPOINT_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.cpp
new file mode 100644
index 00000000000..9d07125476e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.cpp
@@ -0,0 +1,295 @@
+#include "StrokeVertex.h"
+
+#include "../../Convert.h"
+#include "../../StrokeAttribute.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for StrokeVertex instance  -----------*/
+static int StrokeVertex___init__(BPy_StrokeVertex *self, PyObject *args, PyObject *kwds);
+
+static PyObject * StrokeVertex_x( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_y( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_strokeLength( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_u( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_setX( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setY( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setPoint( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setAttribute( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setCurvilinearAbscissa( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setStrokeLength( BPy_StrokeVertex *self , PyObject *args);
+
+/*----------------------StrokeVertex instance definitions ----------------------------*/
+static PyMethodDef BPy_StrokeVertex_methods[] = {	
+//	{"__copy__", ( PyCFunction ) StrokeVertex___copy__, METH_NOARGS, "（ ）Cloning method."},
+	{"x", ( PyCFunction ) StrokeVertex_x, METH_NOARGS, "（ ）Returns the 2D point x coordinate"},
+	{"y", ( PyCFunction ) StrokeVertex_y, METH_NOARGS, "（ ）Returns the 2D point y coordinate"},
+	{"getPoint", ( PyCFunction ) StrokeVertex_getPoint, METH_NOARGS, "（ ）Returns the 2D point coordinates as a Vec2d"},
+	{"attribute", ( PyCFunction ) StrokeVertex_attribute, METH_NOARGS, "（ ）Returns the StrokeAttribute of this StrokeVertex"},
+	{"curvilinearAbscissa", ( PyCFunction ) StrokeVertex_curvilinearAbscissa, METH_NOARGS, "（ ）Returns the curvilinear abscissa "},
+	{"strokeLength", ( PyCFunction ) StrokeVertex_strokeLength, METH_NOARGS, "（ ）Returns the length of the Stroke to which this StrokeVertex belongs"},
+	{"u", ( PyCFunction ) StrokeVertex_u, METH_NOARGS, "（ ）Returns the curvilinear abscissa of this StrokeVertex in the Stroke"},
+	{"setX", ( PyCFunction ) StrokeVertex_setX, METH_VARARGS, "（double r ）Sets the 2D x value "},
+	{"setY", ( PyCFunction ) StrokeVertex_setY, METH_VARARGS, "（double r ）Sets the 2D y value "},
+	{"setPoint", ( PyCFunction ) StrokeVertex_setPoint, METH_VARARGS, "(double x, double y) / ( [x,y] ) Sets the 2D x and y values"},
+	{"setAttribute", ( PyCFunction ) StrokeVertex_setAttribute, METH_VARARGS, "（StrokeAttribute sa ）Sets the attribute."},
+	{"setCurvilinearAbscissa", ( PyCFunction ) StrokeVertex_setCurvilinearAbscissa, METH_VARARGS, "（double r ）Sets the curvilinear abscissa of this StrokeVertex in the Stroke"},
+	{"setStrokeLength", ( PyCFunction ) StrokeVertex_setStrokeLength, METH_VARARGS, "（double r ）Sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the real Stroke's length.) "},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_StrokeVertex type definition ------------------------------*/
+
+PyTypeObject StrokeVertex_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"StrokeVertex",				/* tp_name */
+	sizeof( BPy_StrokeVertex ),	/* 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 ***/
+	BPy_StrokeVertex_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&CurvePoint_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)StrokeVertex___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int StrokeVertex___init__(BPy_StrokeVertex *self, PyObject *args, PyObject *kwds)
+{
+
+	PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0;
+
+    if (! PyArg_ParseTuple(args, "|OOO", &obj1, &obj2, &obj3) )
+        return -1;
+
+	if( !obj1 && !obj2 && !obj3 ){
+		self->sv = new StrokeVertex();
+		
+	} else if( BPy_CurvePoint_Check(obj1) && ((BPy_CurvePoint *) obj1)->cp ) {
+		self->sv = new StrokeVertex( ((BPy_CurvePoint *) obj1)->cp );
+	
+	} else if( BPy_SVertex_Check(obj1) && ((BPy_SVertex *) obj1)->sv ) {
+		self->sv = new StrokeVertex( ((BPy_SVertex *) obj1)->sv );
+	
+	} else if( BPy_StrokeVertex_Check(obj1) && BPy_StrokeVertex_Check(obj2) 
+				&& ((BPy_StrokeVertex *) obj1)->sv && ((BPy_StrokeVertex *) obj2)->sv) {
+	
+		self->sv = new StrokeVertex(	((BPy_StrokeVertex *) obj1)->sv,
+										((BPy_StrokeVertex *) obj2)->sv,
+										PyFloat_AsDouble( obj3 ) );
+	} else {
+		return -1;
+	}
+
+	self->py_cp.cp = self->sv;
+	self->py_cp.py_if0D.if0D = self->sv;
+
+	return 0;
+}
+
+PyObject * StrokeVertex_x( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->x() );
+}
+
+PyObject * StrokeVertex_y( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->y() );
+}
+
+PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self ) {
+	Vec2f v( self->sv->getPoint() );
+	return Vector_from_Vec2f( v );
+}
+
+PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self ) {
+	StrokeAttribute sa( self->sv->attribute() );
+	return BPy_StrokeAttribute_from_StrokeAttribute( sa );
+}
+
+PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->curvilinearAbscissa() );
+}
+
+PyObject * StrokeVertex_strokeLength( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->strokeLength() );
+}
+
+PyObject * StrokeVertex_u( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->u() );
+}
+
+
+PyObject *StrokeVertex_setX( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setX" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setX( r );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setY( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setY" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setY( r );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *StrokeVertex_setPoint( BPy_StrokeVertex *self , PyObject *args) {
+	PyObject *obj1 = 0, *obj2 = 0;
+
+	if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) )) {
+		cout << "ERROR: StrokeVertex_setPoint" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	if( PyList_Check(obj1) && !obj2 ){
+		Vec2f v( 	PyFloat_AsDouble( PyList_GetItem(obj1, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj1, 1) )  );
+		self->sv->setPoint( v );
+	} else if( obj1 && obj2 ){
+		self->sv->setPoint( PyFloat_AsDouble(obj1), PyFloat_AsDouble(obj2) );
+	}
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setAttribute( BPy_StrokeVertex *self , PyObject *args) {
+	PyObject *py_sa;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sa) && BPy_StrokeAttribute_Check(py_sa)  )) {
+		cout << "ERROR: StrokeVertex_setAttribute" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setAttribute(*( ((BPy_StrokeAttribute *) py_sa)->sa ));
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setCurvilinearAbscissa( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setCurvilinearAbscissa" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setCurvilinearAbscissa( r );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *StrokeVertex_setStrokeLength( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setStrokeLength" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setStrokeLength( r );
+
+	Py_RETURN_NONE;
+}
+
+// real 	operator[] (const int i) const
+// real & 	operator[] (const int i)
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.h b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.h
new file mode 100644
index 00000000000..4bc33ea4058
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_STROKEVERTEX_H
+#define FREESTYLE_PYTHON_STROKEVERTEX_H
+
+#include "../CurvePoint.h"
+#include "../../../stroke/Stroke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject StrokeVertex_Type;
+
+#define BPy_StrokeVertex_Check(v)	(( (PyObject *) v)->ob_type == &StrokeVertex_Type)
+
+/*---------------------------Python BPy_StrokeVertex structure definition----------*/
+typedef struct {
+	BPy_CurvePoint py_cp;
+	StrokeVertex *sv;
+} BPy_StrokeVertex;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_STROKEVERTEX_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D/SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/SVertex.cpp
new file mode 100644
index 00000000000..d0c622d1df2
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/SVertex.cpp
@@ -0,0 +1,267 @@
+#include "SVertex.h"
+
+#include "../Convert.h"
+#include "../Id.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for SVertex instance  -----------*/
+static int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds);
+static PyObject * SVertex___copy__( BPy_SVertex *self );
+static PyObject * SVertex_normals( BPy_SVertex *self );
+static PyObject * SVertex_normalsSize( BPy_SVertex *self );
+static PyObject * SVertex_setPoint3D( BPy_SVertex *self , PyObject *args);
+static PyObject * SVertex_setPoint2D( BPy_SVertex *self , PyObject *args);
+static PyObject * SVertex_AddNormal( BPy_SVertex *self , PyObject *args);
+static PyObject * SVertex_setId( BPy_SVertex *self , PyObject *args);
+static PyObject *SVertex_AddFEdge( BPy_SVertex *self , PyObject *args);
+
+/*----------------------SVertex instance definitions ----------------------------*/
+static PyMethodDef BPy_SVertex_methods[] = {
+	{"__copy__", ( PyCFunction ) SVertex___copy__, METH_NOARGS, "（ ）Cloning method."},
+	{"normals", ( PyCFunction ) SVertex_normals, METH_NOARGS, "Returns the normals for this Vertex as a list. In a smooth surface, a vertex has exactly one normal. In a sharp surface, a vertex can have any number of normals."},
+	{"normalsSize", ( PyCFunction ) SVertex_normalsSize, METH_NOARGS, "Returns the number of different normals for this vertex." },
+	{"setPoint3D", ( PyCFunction ) SVertex_setPoint3D, METH_VARARGS, "Sets the 3D coordinates of the SVertex." },
+	{"setPoint2D", ( PyCFunction ) SVertex_setPoint2D, METH_VARARGS, "Sets the 3D projected coordinates of the SVertex." },
+	{"AddNormal", ( PyCFunction ) SVertex_AddNormal, METH_VARARGS, "Adds a normal to the Svertex's set of normals. If the same normal is already in the set, nothing changes." },
+	{"setId", ( PyCFunction ) SVertex_setId, METH_VARARGS, "Sets the Id." },
+	{"AddFEdge", ( PyCFunction ) SVertex_AddFEdge, METH_VARARGS, "Add an FEdge to the list of edges emanating from this SVertex." },	
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_SVertex type definition ------------------------------*/
+
+PyTypeObject SVertex_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"SVertex",				/* tp_name */
+	sizeof( BPy_SVertex ),	/* 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 ***/
+	BPy_SVertex_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&Interface0D_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)SVertex___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds)
+{
+	PyObject *py_point = 0;
+	BPy_Id *py_id = 0;
+
+    if (! PyArg_ParseTuple(args, "|OO", &py_point, &py_id) )
+        return -1;
+	
+	if( py_point && py_id && PyList_Check(py_point) && PyList_Size(py_point) == 3 ) {
+		Vec3r v( 	PyFloat_AsDouble( PyList_GetItem(py_point, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(py_point, 1) ),
+					PyFloat_AsDouble( PyList_GetItem(py_point, 2) )  );
+					
+		self->sv = new SVertex( v, *(py_id->id) );
+	} else {
+		self->sv = new SVertex();
+	}
+	
+	self->py_if0D.if0D = self->sv;
+	
+	return 0;
+}
+
+PyObject * SVertex___copy__( BPy_SVertex *self ) {
+	BPy_SVertex *py_svertex;
+	
+	py_svertex = (BPy_SVertex *) SVertex_Type.tp_new( &SVertex_Type, 0, 0 );
+	
+	py_svertex->sv = self->sv->duplicate();
+	py_svertex->py_if0D.if0D = py_svertex->sv;
+
+	return (PyObject *) py_svertex;
+}
+
+
+PyObject * SVertex_normals( BPy_SVertex *self ) {
+	PyObject *py_normals; 
+	set< Vec3r > normals;
+	
+	py_normals  = PyList_New(NULL);
+	normals = self->sv->normals();
+		
+	for( set< Vec3r >::iterator set_iterator = normals.begin(); set_iterator != normals.end(); set_iterator++ ) {
+		Vec3r v( *set_iterator );
+		PyList_Append( py_normals, Vector_from_Vec3r(v) );
+	}
+	
+	return py_normals;
+}
+
+PyObject * SVertex_normalsSize( BPy_SVertex *self ) {
+	return PyInt_FromLong( self->sv->normalsSize() );
+}
+
+PyObject *SVertex_setPoint3D( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_point;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_point) 
+			&& PyList_Check(py_point) && PyList_Size(py_point) == 3 )) {
+		cout << "ERROR: SVertex_setPoint3D" << endl;
+		Py_RETURN_NONE;
+	}
+
+	Vec3r v( 	PyFloat_AsDouble( PyList_GetItem(py_point, 0) ),
+				PyFloat_AsDouble( PyList_GetItem(py_point, 1) ),
+				PyFloat_AsDouble( PyList_GetItem(py_point, 2) )  );
+	self->sv->setPoint3D( v );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *SVertex_setPoint2D( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_point;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_point) 
+			&& PyList_Check(py_point) && PyList_Size(py_point) == 3 )) {
+		cout << "ERROR: SVertex_setPoint2D" << endl;
+		Py_RETURN_NONE;
+	}
+
+	Vec3r v( 	PyFloat_AsDouble( PyList_GetItem(py_point, 0) ),
+				PyFloat_AsDouble( PyList_GetItem(py_point, 1) ),
+				PyFloat_AsDouble( PyList_GetItem(py_point, 2) )  );
+	self->sv->setPoint2D( v );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *SVertex_AddNormal( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_normal;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_normal) 
+			&& PyList_Check(py_normal) && PyList_Size(py_normal) == 3 )) {
+		cout << "ERROR: SVertex_AddNormal" << endl;
+		Py_RETURN_NONE;
+	}
+
+	Vec3r n( 	PyFloat_AsDouble( PyList_GetItem(py_normal, 0) ),
+				PyFloat_AsDouble( PyList_GetItem(py_normal, 1) ),
+				PyFloat_AsDouble( PyList_GetItem(py_normal, 2) )  );
+	self->sv->AddNormal( n );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *SVertex_setId( BPy_SVertex *self , PyObject *args) {
+	BPy_Id *py_id;
+
+	if( !PyArg_ParseTuple(args, "O", &py_id) ) {
+		cout << "ERROR: SVertex_setId" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setId( *(py_id->id) );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *SVertex_AddFEdge( BPy_SVertex *self , PyObject *args) {
+	PyObject *py_fe;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_FEdge_Check(py_fe) )) {
+		cout << "ERROR: SVertex_AddFEdge" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	self->sv->AddFEdge( ((BPy_FEdge *) py_fe)->fe );
+
+	Py_RETURN_NONE;
+}
+
+
+// virtual bool 	operator== (const SVertex &iBrother)
+// ViewVertex * 	viewvertex ()
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/Interface0D/SVertex.h b/source/blender/freestyle/intern/python/Interface0D/SVertex.h
new file mode 100644
index 00000000000..099417b5139
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/SVertex.h
@@ -0,0 +1,32 @@
+#ifndef FREESTYLE_PYTHON_SVERTEX_H
+#define FREESTYLE_PYTHON_SVERTEX_H
+
+#include "../../view_map/Silhouette.h"
+#include "../Interface0D.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject SVertex_Type;
+
+#define BPy_SVertex_Check(v)	(( (PyObject *) v)->ob_type == &SVertex_Type)
+
+/*---------------------------Python BPy_SVertex structure definition----------*/
+typedef struct {
+	BPy_Interface0D py_if0D;
+	SVertex *sv;
+} BPy_SVertex;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_SVERTEX_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex.cpp
new file mode 100644
index 00000000000..6168d1fb711
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex.cpp
@@ -0,0 +1,158 @@
+#include "ViewVertex.h"
+
+#include "../Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for ViewVertex instance  -----------*/
+static int ViewVertex___init__(BPy_ViewVertex *self);
+static PyObject * ViewVertex_setNature( BPy_ViewVertex *self, PyObject *args );
+
+
+/*----------------------ViewVertex instance definitions ----------------------------*/
+static PyMethodDef BPy_ViewVertex_methods[] = {
+	{"setNature", ( PyCFunction ) ViewVertex_setNature, METH_VARARGS, "（Nature n ）Sets the nature of the vertex."},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_ViewVertex type definition ------------------------------*/
+
+PyTypeObject ViewVertex_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"ViewVertex",				/* tp_name */
+	sizeof( BPy_ViewVertex ),	/* 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 ***/
+	BPy_ViewVertex_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&Interface0D_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)ViewVertex___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int ViewVertex___init__(BPy_ViewVertex *self )
+{	
+	self->py_if0D.if0D = new Interface0D();
+	return 0;
+}
+
+// PyObject * ViewVertex___copy__( BPy_ViewVertex *self ) {
+// 	BPy_ViewVertex *py_vv;
+// 	
+// 	py_vv = (BPy_ViewVertex *) ViewVertex_Type.tp_new( &ViewVertex_Type, 0, 0 );
+// 	
+// 	py_vv->vv = self->vv->duplicate();
+// 	py_svertex->py_if0D.if->sv;
+// 
+// 	return (PyObject *) py_svertex;
+// }
+
+PyObject * ViewVertex_setNature( BPy_ViewVertex *self, PyObject *args ) {
+	PyObject *py_n;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_n) && BPy_Nature_Check(py_n) )) {
+		cout << "ERROR: ViewVertex_setNature" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
+	((ViewVertex *) self->py_if0D.if0D)->setNature( PyInt_AsLong(i) );
+
+	Py_RETURN_NONE;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+// virtual string 	getExactTypeName () const
+
+// void 	setNature (Nature::VertexNature iNature)
+// virtual ViewVertexInternal::orientedViewEdgeIterator 	edgesBegin ()=0
+// virtual ViewVertexInternal::orientedViewEdgeIterator 	edgesEnd ()=0
+// virtual ViewVertexInternal::orientedViewEdgeIterator 	edgesIterator (ViewEdge *iEdge)=0
+// 
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex.h b/source/blender/freestyle/intern/python/Interface0D/ViewVertex.h
new file mode 100644
index 00000000000..98bcb9bac90
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_VIEWVERTEX_H
+#define FREESTYLE_PYTHON_VIEWVERTEX_H
+
+#include "../../view_map/ViewMap.h"
+#include "../Interface0D.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject ViewVertex_Type;
+
+#define BPy_ViewVertex_Check(v)	(( (PyObject *) v)->ob_type == &ViewVertex_Type)
+
+/*---------------------------Python BPy_ViewVertex structure definition----------*/
+typedef struct {
+	BPy_Interface0D py_if0D;
+} BPy_ViewVertex;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_VIEWVERTEX_H */
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/NonTVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/NonTVertex.cpp
new file mode 100644
index 00000000000..772a385139e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/NonTVertex.cpp
@@ -0,0 +1,132 @@
+ PyObject *_wrap_NonTVertex_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getPoint3D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getProjectedX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getProjectedY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getProjectedZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getPoint2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_castToSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_castToViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_castToNonTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_NonTVertex__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_NonTVertex__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_NonTVertex(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_NonTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_svertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_viewedges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_SetSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_SetViewEdges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_AddIncomingViewEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_AddOutgoingViewEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_AddViewEdge__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_AddViewEdge__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_AddViewEdge(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_Replace(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edges_end__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edges_end__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edges_end(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edgesBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edgesEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_NonTVertex_edgesIterator(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/TVertex.cpp
new file mode 100644
index 00000000000..715170c1422
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/TVertex.cpp
@@ -0,0 +1,184 @@
+ PyObject *_wrap_TVertex_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getPoint3D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getProjectedX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getProjectedY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getProjectedZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getPoint2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_castToViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_castToTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_TVertex__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_TVertex__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_TVertex(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_frontSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_backSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_frontEdgeA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_frontEdgeB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_backEdgeA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_backEdgeB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeA__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeA__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeA(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeB__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeB__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetFrontEdgeB(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeA__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeA__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeA(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeB__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeB__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetBackEdgeB(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_SetId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_GetSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_Replace(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_mate(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edges_end__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edges_end__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edges_end(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edgesBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edgesEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TVertex_edgesIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TVertex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface0DIterator.cpp b/source/blender/freestyle/intern/python/Interface0DIterator.cpp
new file mode 100644
index 00000000000..48b7560acea
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface0DIterator.cpp
@@ -0,0 +1,104 @@
+ PyObject *_wrap_Interface0DIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getObject(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator___deref__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_increment(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_decrement(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_isBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_isEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator___eq__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator___ne__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_t(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_u(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getPoint3D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getProjectedX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getProjectedY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getProjectedZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getPoint2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getFEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_getNature(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_castToSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_castToViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_castToNonTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Interface0DIterator_castToTVertex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface1D.cpp b/source/blender/freestyle/intern/python/Interface1D.cpp
new file mode 100644
index 00000000000..f1a14b5d62f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D.cpp
@@ -0,0 +1,223 @@
+#include "Interface1D.h"
+
+#include "Convert.h"
+#include "Interface1D/FEdge.h"
+#include "Interface1D/Stroke.h"
+#include "MediumType.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Interface1D instance  -----------*/
+static int Interface1D___init__(BPy_Interface1D *self, PyObject *args, PyObject *kwds);
+static void Interface1D___dealloc__(BPy_Interface1D *self);
+static PyObject * Interface1D___repr__(BPy_Interface1D *self);
+
+static PyObject *Interface1D_getExactTypeName( BPy_Interface1D *self );
+static PyObject *Interface1D_getVertices( BPy_Interface1D *self );
+static PyObject *Interface1D_getPoints( BPy_Interface1D *self );
+static PyObject *Interface1D_getLength2D( BPy_Interface1D *self );
+static PyObject *Interface1D_getId( BPy_Interface1D *self );
+static PyObject *Interface1D_getNature( BPy_Interface1D *self );
+static PyObject *Interface1D_getTimeStamp( BPy_Interface1D *self );
+static PyObject *Interface1D_setTimeStamp( BPy_Interface1D *self, PyObject *args);
+
+/*----------------------Interface1D instance definitions ----------------------------*/
+static PyMethodDef BPy_Interface1D_methods[] = {
+	{"getExactTypeName", ( PyCFunction ) Interface1D_getExactTypeName, METH_NOARGS, "（ ）Returns the string of the name of the interface."},
+	{"getVertices", ( PyCFunction ) Interface1D_getVertices, METH_NOARGS, "Returns the vertices"},
+	{"getPoints", ( PyCFunction ) Interface1D_getPoints, METH_NOARGS, "Returns the points. The difference with getVertices() is that here we can iterate over points of the 1D element at any given sampling. At each call, a virtual point is created."},
+	{"getLength2D", ( PyCFunction ) Interface1D_getLength2D, METH_NOARGS, "Returns the 2D length of the 1D element"},
+	{"getId", ( PyCFunction ) Interface1D_getId, METH_NOARGS, "Returns the Id of the 1D element"},
+	{"getNature", ( PyCFunction ) Interface1D_getNature, METH_NOARGS, "Returns the nature of the 1D element"},
+	{"getTimeStamp", ( PyCFunction ) Interface1D_getTimeStamp, METH_NOARGS, "Returns the time stamp of the 1D element. Mainly used for selection"},
+	{"setTimeStamp", ( PyCFunction ) Interface1D_setTimeStamp, METH_VARARGS, "Sets the time stamp for the 1D element"},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Interface1D type definition ------------------------------*/
+
+PyTypeObject Interface1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Interface1D",				/* tp_name */
+	sizeof( BPy_Interface1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)Interface1D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)Interface1D___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_Interface1D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Interface1D___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 Interface1D_Init( PyObject *module )
+{
+	PyObject *tmp;
+	
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &Interface1D_Type ) < 0 )
+		return;
+	Py_INCREF( &Interface1D_Type );
+	PyModule_AddObject(module, "Interface1D", (PyObject *)&Interface1D_Type);
+	
+	if( PyType_Ready( &FEdge_Type ) < 0 )
+		return;
+	Py_INCREF( &FEdge_Type );
+	PyModule_AddObject(module, "FEdge", (PyObject *)&FEdge_Type);
+
+	if( PyType_Ready( &Stroke_Type ) < 0 )
+		return;
+	Py_INCREF( &Stroke_Type );
+	PyModule_AddObject(module, "Stroke", (PyObject *)&Stroke_Type);
+
+	tmp = BPy_MediumType_from_MediumType( Stroke::DRY_MEDIUM ); PyDict_SetItemString( Stroke_Type.tp_dict, "DRY_MEDIUM", tmp); Py_DECREF(tmp);
+	tmp = BPy_MediumType_from_MediumType( Stroke::HUMID_MEDIUM ); PyDict_SetItemString( Stroke_Type.tp_dict, "HUMID_MEDIUM", tmp); Py_DECREF(tmp);
+	tmp = BPy_MediumType_from_MediumType( Stroke::OPAQUE_MEDIUM ); PyDict_SetItemString( Stroke_Type.tp_dict, "OPAQUE_MEDIUM", tmp); Py_DECREF(tmp);
+
+	
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int Interface1D___init__(BPy_Interface1D *self, PyObject *args, PyObject *kwds)
+{
+	self->if1D = new Interface1D();
+	return 0;
+}
+
+void Interface1D___dealloc__(BPy_Interface1D* self)
+{
+	delete self->if1D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+PyObject * Interface1D___repr__(BPy_Interface1D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D );
+}
+
+PyObject *Interface1D_getExactTypeName( BPy_Interface1D *self ) {
+	return PyString_FromString( self->if1D->getExactTypeName().c_str() );	
+}
+
+PyObject *Interface1D_getVertices( BPy_Interface1D *self ) {
+	return PyList_New(0);
+}
+
+PyObject *Interface1D_getPoints( BPy_Interface1D *self ) {
+	return PyList_New(0);
+}
+
+PyObject *Interface1D_getLength2D( BPy_Interface1D *self ) {
+	return PyFloat_FromDouble( (double) self->if1D->getLength2D() );
+}
+
+PyObject *Interface1D_getId( BPy_Interface1D *self ) {
+	Id id( self->if1D->getId() );
+	return BPy_Id_from_Id( id );
+}
+
+PyObject *Interface1D_getNature( BPy_Interface1D *self ) {
+	return BPy_Nature_from_Nature( self->if1D->getNature() );
+}
+
+PyObject *Interface1D_getTimeStamp( BPy_Interface1D *self ) {
+	return PyInt_FromLong( self->if1D->getTimeStamp() );
+}
+
+PyObject *Interface1D_setTimeStamp( BPy_Interface1D *self, PyObject *args) {
+	int timestamp = 0 ;
+
+	if( !PyArg_ParseTuple(args, (char *)"i", &timestamp) ) {
+		cout << "ERROR: Interface1D_setTimeStamp" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	self->if1D->setTimeStamp( timestamp );
+
+	Py_RETURN_NONE;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/source/blender/freestyle/intern/python/Interface1D.h b/source/blender/freestyle/intern/python/Interface1D.h
new file mode 100644
index 00000000000..c49a8c130b0
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D.h
@@ -0,0 +1,35 @@
+#ifndef FREESTYLE_PYTHON_INTERFACE1D_H
+#define FREESTYLE_PYTHON_INTERFACE1D_H
+
+#include "../view_map/Interface1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Interface1D_Type;
+
+#define BPy_Interface1D_Check(v)	(( (PyObject *) v)->ob_type == &Interface1D_Type)
+
+/*---------------------------Python BPy_Interface1D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	Interface1D *if1D;
+} BPy_Interface1D;
+
+/*---------------------------Python BPy_Interface1D visible prototypes-----------*/
+
+PyMODINIT_FUNC Interface1D_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_INTERFACE1D_H */
diff --git a/source/blender/freestyle/intern/python/Interface1D/Curve.cpp b/source/blender/freestyle/intern/python/Interface1D/Curve.cpp
new file mode 100644
index 00000000000..4fac75b3f0d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/Curve.cpp
@@ -0,0 +1,112 @@
+ PyObject *_wrap_Curve_computeCurvatureAndOrientation(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_back__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_back__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_back(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_front__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_front__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_push_vertex_front(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_getLength2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_nSegments(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_setId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsBegin__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsBegin__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsBegin(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsEnd__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsEnd__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curvePointsEnd(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curveVerticesBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_curveVerticesEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_verticesBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_verticesEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsBegin__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsBegin__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsBegin(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsEnd__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsEnd__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curve_pointsEnd(PyObject *self, PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface1D/Curve/Chain.cpp b/source/blender/freestyle/intern/python/Interface1D/Curve/Chain.cpp
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/Curve/Chain.cpp
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge.cpp
new file mode 100644
index 00000000000..0cdfb9f1e0d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge.cpp
@@ -0,0 +1,341 @@
+#include "FEdge.h"
+
+#include "../Convert.h"
+#include "../Interface0D/SVertex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for FEdge instance  -----------*/
+static int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds);
+static PyObject * FEdge___copy__( BPy_FEdge *self );
+static PyObject * FEdge_vertexA( BPy_FEdge *self );
+static PyObject * FEdge_vertexB( BPy_FEdge *self );
+static PyObject * FEdge___getitem__( BPy_FEdge *self, PyObject *args );
+static PyObject * FEdge_nextEdge( BPy_FEdge *self );
+static PyObject * FEdge_previousEdge( BPy_FEdge *self );
+static PyObject * FEdge_getVertices( BPy_FEdge *self );
+static PyObject * FEdge_getPoints( BPy_FEdge *self );
+static PyObject * FEdge_isSmooth( BPy_FEdge *self );
+static PyObject * FEdge_setVertexA( BPy_FEdge *self , PyObject *args);
+static PyObject * FEdge_setVertexB( BPy_FEdge *self , PyObject *args);
+static PyObject * FEdge_setId( BPy_FEdge *self , PyObject *args);
+static PyObject * FEdge_setNextEdge( BPy_FEdge *self , PyObject *args);
+static PyObject * FEdge_setPreviousEdge( BPy_FEdge *self , PyObject *args);
+static PyObject * FEdge_setSmooth( BPy_FEdge *self , PyObject *args); 
+static PyObject * FEdge_setNature( BPy_FEdge *self, PyObject *args );
+
+/*----------------------FEdge instance definitions ----------------------------*/
+static PyMethodDef BPy_FEdge_methods[] = {	
+	{"__copy__", ( PyCFunction ) FEdge___copy__, METH_NOARGS, "() Cloning method."},
+	{"vertexA", ( PyCFunction ) FEdge_vertexA, METH_NOARGS, "() Returns the first SVertex."},
+	{"vertexB", ( PyCFunction ) FEdge_vertexB, METH_NOARGS, "() Returns the second SVertex."},
+	{"__getitem__", ( PyCFunction ) FEdge___getitem__, METH_VARARGS, "(int i) Returns the first SVertex if i=0, the seccond SVertex if i=1."},
+	{"nextEdge", ( PyCFunction ) FEdge_nextEdge, METH_NOARGS, "() Returns the FEdge following this one in the ViewEdge. If this FEdge is the last of the ViewEdge, 0 is returned."},
+	{"previousEdge", ( PyCFunction ) FEdge_previousEdge, METH_NOARGS, "Returns the Edge preceding this one in the ViewEdge. If this FEdge is the first one of the ViewEdge, 0 is returned."},
+	{"getVertices", ( PyCFunction ) FEdge_getVertices, METH_NOARGS, "Returns the vertices"},
+	{"getPoints", ( PyCFunction ) FEdge_getPoints, METH_NOARGS, "Returns the points. The difference with getVertices() is that here we can iterate over points of the 1D element at any given sampling. At each call, a virtual point is created."}, 
+	{"isSmooth", ( PyCFunction ) FEdge_isSmooth, METH_NOARGS, "() Returns true if this FEdge is a smooth FEdge."},
+	{"setVertexA", ( PyCFunction ) FEdge_setVertexA, METH_VARARGS, "(SVertex v) Sets the first SVertex. ."},
+	{"setVertexB", ( PyCFunction ) FEdge_setVertexB, METH_VARARGS, "(SVertex v) Sets the second SVertex. "},
+	{"setId", ( PyCFunction ) FEdge_setId, METH_VARARGS, "(Id id) Sets the FEdge Id ."},
+	{"setNextEdge", ( PyCFunction ) FEdge_setNextEdge, METH_VARARGS, "(FEdge e) Sets the pointer to the next FEdge. "},
+	{"setPreviousEdge", ( PyCFunction ) FEdge_setPreviousEdge, METH_VARARGS, "(FEdge e) Sets the pointer to the previous FEdge. "},
+	{"setSmooth", ( PyCFunction ) FEdge_setSmooth, METH_VARARGS, "(bool b) Sets the flag telling whether this FEdge is smooth or sharp. true for Smooth, false for Sharp. "},
+	{"setNature", ( PyCFunction ) FEdge_setNature, METH_VARARGS, "(Nature n) Sets the nature of this FEdge. "},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_FEdge type definition ------------------------------*/
+
+PyTypeObject FEdge_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"FEdge",				/* tp_name */
+	sizeof( BPy_FEdge ),	/* 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 ***/
+	BPy_FEdge_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&Interface1D_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)FEdge___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+	
+int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds)
+{
+
+	PyObject *obj1 = 0, *obj2 = 0;
+
+    if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) )
+        return -1;
+
+	if( !obj1 && !obj2 ){
+		self->fe = new FEdge();
+	} else if( BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
+		self->fe = new FEdge( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv );
+	} else {
+		return -1;
+	}
+
+	self->py_if1D.if1D = self->fe;
+
+	return 0;
+}
+
+
+PyObject * FEdge___copy__( BPy_FEdge *self ) {
+	BPy_FEdge *py_fe;
+	
+	py_fe = (BPy_FEdge *) FEdge_Type.tp_new( &FEdge_Type, 0, 0 );
+	
+	py_fe->fe = new FEdge( *(self->fe) );
+	py_fe->py_if1D.if1D = py_fe->fe;
+
+	return (PyObject *) py_fe;
+}
+
+PyObject * FEdge_vertexA( BPy_FEdge *self ) {	
+	if( self->fe->vertexA() ){
+		return BPy_SVertex_from_SVertex( *(self->fe->vertexA()) );
+	}
+		
+	Py_RETURN_NONE;
+}
+
+PyObject * FEdge_vertexB( BPy_FEdge *self ) {
+	if( self->fe->vertexB() ){
+		return BPy_SVertex_from_SVertex( *(self->fe->vertexB()) );
+	}
+		
+	Py_RETURN_NONE;
+}
+
+
+PyObject * FEdge___getitem__( BPy_FEdge *self, PyObject *args ) {
+	int i;
+
+	if(!( PyArg_ParseTuple(args, "i", &i) && (i == 0 || i == 1)  )) {
+		cout << "ERROR: FEdge___getitem__" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	if( SVertex *v = self->fe->operator[](i) )
+		return BPy_SVertex_from_SVertex( *v );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * FEdge_nextEdge( BPy_FEdge *self ) {
+	if( FEdge *fe = self->fe->nextEdge() )
+		return BPy_FEdge_from_FEdge( *fe );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * FEdge_previousEdge( BPy_FEdge *self ) {
+	if( FEdge *fe = self->fe->previousEdge() )
+		return BPy_FEdge_from_FEdge( *fe );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * FEdge_isSmooth( BPy_FEdge *self ) {
+	return PyBool_from_bool( self->fe->isSmooth() );
+}
+	
+PyObject *FEdge_setVertexA( BPy_FEdge *self , PyObject *args) {
+	PyObject *py_sv;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) {
+		cout << "ERROR: FEdge_setVertexA" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setVertexA( ((BPy_SVertex *) py_sv)->sv );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *FEdge_setVertexB( BPy_FEdge *self , PyObject *args) {
+	PyObject *py_sv;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) {
+		cout << "ERROR: FEdge_setVertexB" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setVertexB( ((BPy_SVertex *) py_sv)->sv );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *FEdge_setId( BPy_FEdge *self , PyObject *args) {
+	PyObject *py_id;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_id) && BPy_Id_Check(py_id) )) {
+		cout << "ERROR: FEdge_setId" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setId(*( ((BPy_Id *) py_id)->id ));
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *FEdge_setNextEdge( BPy_FEdge *self , PyObject *args) {
+	PyObject *py_fe;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_FEdge_Check(py_fe) )) {
+		cout << "ERROR: FEdge_setNextEdge" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setNextEdge( ((BPy_FEdge *) py_fe)->fe );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *FEdge_setPreviousEdge( BPy_FEdge *self , PyObject *args) {
+	PyObject *py_fe;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_FEdge_Check(py_fe) )) {
+		cout << "ERROR: FEdge_setPreviousEdge" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setPreviousEdge( ((BPy_FEdge *) py_fe)->fe );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *FEdge_setSmooth( BPy_FEdge *self , PyObject *args) {
+	int b;
+
+	if(!( PyArg_ParseTuple(args, "i", &b) )) {
+		cout << "ERROR: FEdge_setSmooth" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->fe->setSmooth( (bool) b );
+
+	Py_RETURN_NONE;
+}
+
+PyObject * FEdge_setNature( BPy_FEdge *self, PyObject *args ) {
+	PyObject *py_n;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_n) && BPy_Nature_Check(py_n) )) {
+		cout << "ERROR: FEdge_setNature" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
+	((FEdge *) self->py_if1D.if1D)->setNature( PyInt_AsLong(i) );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *FEdge_getVertices( BPy_FEdge *self ) {
+	PyObject *py_vertices = PyList_New(NULL);
+		
+	for( Interface0DIterator it = self->fe->verticesBegin(); it != self->fe->verticesEnd(); it++ ) {
+		PyList_Append( py_vertices, BPy_Interface0D_from_Interface0D( *it ) );
+	}
+	
+	return py_vertices;
+}
+
+PyObject *FEdge_getPoints( BPy_FEdge *self ) {
+	PyObject *py_points = PyList_New(NULL);
+	
+	for( Interface0DIterator it = self->fe->pointsBegin(); it != self->fe->pointsEnd(); it++ ) {
+		PyList_Append( py_points, BPy_Interface0D_from_Interface0D( *it ) );
+	}
+	
+	return py_points;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge.h b/source/blender/freestyle/intern/python/Interface1D/FEdge.h
new file mode 100644
index 00000000000..230a5f36954
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_FEDGE_H
+#define FREESTYLE_PYTHON_FEDGE_H
+
+#include "../Interface1D.h"
+#include "../../view_map/Silhouette.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject FEdge_Type;
+
+#define BPy_FEdge_Check(v)	(( (PyObject *) v)->ob_type == &FEdge_Type)
+
+/*---------------------------Python BPy_FEdge structure definition----------*/
+typedef struct {
+	BPy_Interface1D py_if1D;
+	FEdge *fe;
+} BPy_FEdge;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_FEDGE_H */
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSharp.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSharp.cpp
new file mode 100644
index 00000000000..da409ffe209
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSharp.cpp
@@ -0,0 +1,44 @@
+ PyObject *_wrap_FEdgeSharp_duplicate(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_normalA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_normalB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_aMaterialIndex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_aMaterial(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_bMaterialIndex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_bMaterial(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_SetNormalA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_SetNormalB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_SetaMaterialIndex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSharp_SetbMaterialIndex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSmooth.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSmooth.cpp
new file mode 100644
index 00000000000..e453bbdc863
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/FEdgeSmooth.cpp
@@ -0,0 +1,32 @@
+ PyObject *_wrap_FEdgeSmooth_dupplicate(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_face(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_normal(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_materialIndex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_material(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_SetFace(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_SetNormal(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FEdgeSmooth_SetMaterialIndex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Interface1D/Stroke.cpp b/source/blender/freestyle/intern/python/Interface1D/Stroke.cpp
new file mode 100644
index 00000000000..9951f21a0e1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/Stroke.cpp
@@ -0,0 +1,314 @@
+#include "Stroke.h"
+
+#include "../Convert.h"
+#include "../Interface0D/SVertex.h"
+#include "../../stroke/StrokeIterators.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Stroke instance  -----------*/
+static int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds);
+
+static PyObject * Stroke_ComputeSampling( BPy_Stroke *self, PyObject *args );
+static PyObject * Stroke_Resample( BPy_Stroke *self, PyObject *args );
+//static PyObject * Stroke_InsertVertex( BPy_Stroke *self, PyObject *args );
+static PyObject * Stroke_RemoveVertex( BPy_Stroke *self, PyObject *args );
+static PyObject * Stroke_getMediumType( BPy_Stroke *self );
+static PyObject * Stroke_getTextureId( BPy_Stroke *self );
+static PyObject * Stroke_hasTips( BPy_Stroke *self );
+static PyObject * Stroke_setId( BPy_Stroke *self , PyObject *args);
+static PyObject * Stroke_setLength( BPy_Stroke *self , PyObject *args);
+static PyObject * Stroke_setMediumType( BPy_Stroke *self , PyObject *args);
+static PyObject * Stroke_setTextureId( BPy_Stroke *self , PyObject *args);
+static PyObject * Stroke_setTips( BPy_Stroke *self , PyObject *args);
+static PyObject * Stroke_strokeVerticesSize( BPy_Stroke *self );
+static PyObject * Stroke_getStrokeVertices( BPy_Stroke *self );
+
+/*----------------------Stroke instance definitions ----------------------------*/
+static PyMethodDef BPy_Stroke_methods[] = {	
+	{"ComputeSampling", ( PyCFunction ) Stroke_ComputeSampling, METH_VARARGS, "(int nVertices) Compute the sampling needed to get nVertices vertices. If the specified number of vertices is less than the actual number of vertices, the actual sampling value is returned."},
+		{"Resample", ( PyCFunction ) Stroke_Resample, METH_VARARGS, "(float f | int n) Resampling method. If the argument is a float, Resamples the curve with a given sampling; if this sampling is < to the actual sampling value, no resampling is done. If the argument is an integer, Resamples the curve so that it eventually has n. That means it is going to add n-vertices_size, if vertices_size is the number of points we already have. Is vertices_size >= n, no resampling is done."},
+	{"RemoveVertex", ( PyCFunction ) Stroke_RemoveVertex, METH_VARARGS, "(StrokeVertex sv) Removes the stroke vertex sv from the stroke. The length and curvilinear abscissa are updated consequently."},
+	{"getMediumType", ( PyCFunction ) Stroke_getMediumType, METH_NOARGS, "() Returns the MediumType used for this Stroke."},
+	{"getTextureId", ( PyCFunction ) Stroke_getTextureId, METH_NOARGS, "() Returns the id of the texture used to simulate th marks system for this Stroke."},
+	{"hasTips", ( PyCFunction ) Stroke_hasTips, METH_NOARGS, "() Returns true if this Stroke uses a texture with tips, false otherwise."},
+	{"setId", ( PyCFunction ) Stroke_setId, METH_VARARGS, "(Id id) Sets the Id of the Stroke."},
+	{"setLength", ( PyCFunction ) Stroke_setLength, METH_VARARGS, "(float l) Sets the 2D length of the Stroke."},
+	{"setMediumType", ( PyCFunction ) Stroke_setMediumType, METH_VARARGS, "(MediumType mt) Sets the medium type that must be used for this Stroke."},
+	{"setTextureId", ( PyCFunction ) Stroke_setTextureId, METH_VARARGS, "(unsigned int id) Sets the texture id to be used to simulate the marks system for this Stroke."},
+	{"setTips", ( PyCFunction ) Stroke_setTips, METH_VARARGS, "(bool b) Sets the flag telling whether this stroke is using a texture with tips or not."},
+	{"strokeVerticesSize", ( PyCFunction ) Stroke_strokeVerticesSize, METH_NOARGS, "() Returns the number of StrokeVertex constituing the Stroke."},
+	{"getStrokeVertices", ( PyCFunction ) Stroke_getStrokeVertices, METH_NOARGS, "() Returns the stroke vertices. The difference with vertices() is that here we can iterate over points of the 1D element at a any given sampling. Indeed, for each iteration, a virtual point is created."},
+	//{"InsertVertex", ( PyCFunction ) Stroke_InsertVertex, METH_NOARGS, "(StrokeVertex sv, int i) Inserts the stroke vertex iVertex in the stroke before i. The length, curvilinear abscissa are updated consequently."},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Stroke type definition ------------------------------*/
+
+PyTypeObject Stroke_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Stroke",				/* tp_name */
+	sizeof( BPy_Stroke ),	/* 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 ***/
+	BPy_Stroke_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&Interface1D_Type,				/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Stroke___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--------------------------------
+
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+// Stroke ()
+// template<class InputVertexIterator> Stroke (InputVertexIterator iBegin, InputVertexIterator iEnd)
+
+int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds)
+{
+	PyObject *obj1 = 0, *obj2 = 0;
+
+    if (! PyArg_ParseTuple(args, "|OO", &obj1) )
+        return -1;
+
+	if( !obj1 && !obj2 ){
+		self->s = new Stroke();
+
+	// template<class InputVertexIterator> Stroke (InputVertexIterator iBegin, InputVertexIterator iEnd)
+	//
+	// pb: - need to be able to switch representation: InputVertexIterator <=> position
+	//     - is it even used ? not even in SWIG version
+	} else {
+		return -1;
+	}
+
+	self->py_if1D.if1D = self->s;
+
+	return 0;
+}
+
+PyObject * Stroke_ComputeSampling( BPy_Stroke *self, PyObject *args ) {	
+	int i;
+
+	if(!( PyArg_ParseTuple(args, "i", &i)  )) {
+		cout << "ERROR: Stroke_ComputeSampling" << endl;
+		Py_RETURN_NONE;
+	}
+
+	return PyFloat_FromDouble( self->s->ComputeSampling( i ) );
+}
+
+PyObject * Stroke_Resample( BPy_Stroke *self, PyObject *args ) {	
+	PyObject *obj;
+
+	if(!( PyArg_ParseTuple(args, "O", &obj) )) {
+		cout << "ERROR: Stroke_Resample" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( PyInt_Check(obj) )
+		self->s->Resample( (int) PyInt_AsLong(obj) );
+	else if( PyFloat_Check(obj) )
+		self->s->Resample( (float) PyFloat_AsDouble(obj) );
+		
+	Py_RETURN_NONE;
+}
+
+
+PyObject * Stroke_RemoveVertex( BPy_Stroke *self, PyObject *args ) {	
+	PyObject *py_sv;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sv) )) {
+		cout << "ERROR: Stroke_RemoveVertex" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( BPy_StrokeVertex_Check(py_sv) && ((BPy_StrokeVertex *) py_sv)->sv )
+		self->s->RemoveVertex( ((BPy_StrokeVertex *) py_sv)->sv );
+		
+	Py_RETURN_NONE;
+}
+
+// pb: 'iterator <=> list' correspondence
+// void 	InsertVertex (StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next)
+
+PyObject * Stroke_getMediumType( BPy_Stroke *self ) {	
+	return BPy_MediumType_from_MediumType( self->s->getMediumType() );
+}
+
+PyObject * Stroke_getTextureId( BPy_Stroke *self ) {	
+	return PyInt_FromLong( self->s->getTextureId() );
+}
+
+PyObject * Stroke_hasTips( BPy_Stroke *self ) {	
+	return PyBool_from_bool( self->s->hasTips() );
+}
+
+
+PyObject *Stroke_setId( BPy_Stroke *self , PyObject *args) {
+	PyObject *py_id;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_id) && BPy_Id_Check(py_id)  )) {
+		cout << "ERROR: Stroke_setId" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( ((BPy_Id *) py_id)->id )
+		self->s->setId(*( ((BPy_Id *) py_id)->id ));
+
+	Py_RETURN_NONE;
+}
+
+PyObject *Stroke_setLength( BPy_Stroke *self , PyObject *args) {
+	float f;
+
+	if(!( PyArg_ParseTuple(args, "f", &f) )) {
+		cout << "ERROR: Stroke_setLength" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->s->setLength( f );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *Stroke_setMediumType( BPy_Stroke *self , PyObject *args) {
+	PyObject *py_mt;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_mt) && BPy_MediumType_Check(py_mt)  )) {
+		cout << "ERROR: Stroke_setMediumType" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->s->setMediumType( static_cast<Stroke::MediumType>(PyInt_AsLong(py_mt)) );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *Stroke_setTextureId( BPy_Stroke *self , PyObject *args) {
+	unsigned int i;
+
+	if(!( PyArg_ParseTuple(args, "I", &i) )) {
+		cout << "ERROR: Stroke_setTextureId" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->s->setTextureId( i );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *Stroke_setTips( BPy_Stroke *self , PyObject *args) {
+	PyObject *py_b;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_b) && PyBool_Check(py_b)  )) {
+		cout << "ERROR: Stroke_setTips" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->s->setTips( py_b == Py_True );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject * Stroke_strokeVerticesSize( BPy_Stroke *self ) {	
+	return PyInt_FromLong( self->s->strokeVerticesSize() );
+}
+
+
+PyObject *Stroke_getStrokeVertices( BPy_Stroke *self ) {
+	PyObject *py_stroke_vertices = PyList_New(NULL);
+		
+	for( StrokeInternal::StrokeVertexIterator it = self->s->strokeVerticesBegin();
+		it != self->s->strokeVerticesEnd();
+		it++ ) {
+		PyList_Append( py_stroke_vertices, BPy_StrokeVertex_from_StrokeVertex( *it ) );
+	}
+	
+	return py_stroke_vertices;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/Interface1D/Stroke.h b/source/blender/freestyle/intern/python/Interface1D/Stroke.h
new file mode 100644
index 00000000000..fc4b426fd53
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/Stroke.h
@@ -0,0 +1,31 @@
+#ifndef FREESTYLE_PYTHON_STROKE_H
+#define FREESTYLE_PYTHON_STROKE_H
+
+#include "../Interface1D.h"
+#include "../../stroke/Stroke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Stroke_Type;
+
+#define BPy_Stroke_Check(v)	(( (PyObject *) v)->ob_type == &Stroke_Type)
+
+/*---------------------------Python BPy_Stroke structure definition----------*/
+typedef struct {
+	BPy_Interface1D py_if1D;
+	Stroke *s;
+} BPy_Stroke;
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_STROKE_H */
diff --git a/source/blender/freestyle/intern/python/Interface1D/ViewEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/ViewEdge.cpp
new file mode 100644
index 00000000000..1b55b601c89
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Interface1D/ViewEdge.cpp
@@ -0,0 +1,236 @@
+ PyObject *_wrap_ViewEdge_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_getNature(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_userdata_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_userdata_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewEdge__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewEdge__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewEdge__SWIG_2(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewEdge__SWIG_3(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewEdge(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ViewEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_A(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_B(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_fedgeA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_fedgeB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_viewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_aShape__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_isClosed(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_getChainingTimeStamp(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_aShape__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_aShape(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_bShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluders(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_splittingId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetNature(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetFEdgeA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetFEdgeB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_UpdateFEdges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetaShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_SetQI(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_setChainingTimeStamp(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_AddOccluder(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_setSplittingId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_intersect_2d_area(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_include_in_2d_area(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_getLength2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_qi(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluders_begin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluders_end(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluders_size(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluders_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occludee(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occluded_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_occludee_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_shape_id(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_shape_importance(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_verticesBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_verticesEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsBegin__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsBegin__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsBegin(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsEnd__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsEnd__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewEdge_pointsEnd(PyObject *self, PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Material.cpp b/source/blender/freestyle/intern/python/Material.cpp
new file mode 100644
index 00000000000..459de449336
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Material.cpp
@@ -0,0 +1,112 @@
+ PyObject *_wrap_Material_diffuse(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_diffuseR(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_diffuseG(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_diffuseB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_diffuseA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_specular(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_specularR(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_specularG(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_specularB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_specularA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_ambient(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_ambientR(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_ambientG(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_ambientB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_ambientA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_emission(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_emissionR(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_emissionG(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_emissionB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_emissionA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_shininess(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_SetDiffuse(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_SetSpecular(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_SetAmbient(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_SetEmission(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material_SetShininess(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material___ne__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Material___eq__(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/MediumType.cpp b/source/blender/freestyle/intern/python/MediumType.cpp
new file mode 100644
index 00000000000..f0c5fcc58a4
--- /dev/null
+++ b/source/blender/freestyle/intern/python/MediumType.cpp
@@ -0,0 +1,119 @@
+#include "MediumType.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for MediumType instance  -----------*/
+static int MediumType___init__(BPy_MediumType *self, PyObject *args, PyObject *kwds);
+
+/*----------------------MediumType instance definitions ----------------------------*/
+static PyMethodDef BPy_MediumType_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_MediumType type definition ------------------------------*/
+
+PyTypeObject MediumType_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"MediumType",				/* tp_name */
+	sizeof( BPy_MediumType ),	/* 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 ***/
+	BPy_MediumType_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&PyInt_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)MediumType___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,			/* 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--------------------------------
+
+int MediumType___init__(BPy_MediumType *self, PyObject *args, PyObject *kwds)
+{
+    if (PyInt_Type.tp_init((PyObject *)self, args, kwds) < 0)
+        return -1;
+	
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/MediumType.h b/source/blender/freestyle/intern/python/MediumType.h
new file mode 100644
index 00000000000..d56594e0f68
--- /dev/null
+++ b/source/blender/freestyle/intern/python/MediumType.h
@@ -0,0 +1,33 @@
+#ifndef FREESTYLE_PYTHON_MEDIUMTYPE_H
+#define FREESTYLE_PYTHON_MEDIUMTYPE_H
+
+#include "../stroke/Stroke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject MediumType_Type;
+
+#define BPy_MediumType_Check(v)	(( (PyObject *) v)->ob_type == &MediumType_Type)
+
+/*---------------------------Python BPy_MediumType structure definition----------*/
+typedef struct {
+	PyIntObject i;
+} BPy_MediumType;
+
+/*---------------------------Python BPy_MediumType visible prototypes-----------*/
+
+PyMODINIT_FUNC MediumType_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_MEDIUMTYPE_H */
diff --git a/source/blender/freestyle/intern/python/Nature.cpp b/source/blender/freestyle/intern/python/Nature.cpp
new file mode 100644
index 00000000000..14357949022
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Nature.cpp
@@ -0,0 +1,149 @@
+#include "Nature.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for Nature instance  -----------*/
+static int Nature___init__(BPy_Nature *self, PyObject *args, PyObject *kwds);
+
+/*----------------------Nature instance definitions ----------------------------*/
+static PyMethodDef BPy_Nature_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_Nature type definition ------------------------------*/
+
+PyTypeObject Nature_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"Nature",				/* tp_name */
+	sizeof( BPy_Nature ),	/* 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 ***/
+	BPy_Nature_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	&PyInt_Type,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)Nature___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,			/* 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 Nature_Init( PyObject *module )
+{	
+	PyObject *tmp;
+	
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &Nature_Type ) < 0 )
+		return;
+	Py_INCREF( &Nature_Type );
+	PyModule_AddObject(module, "Nature", (PyObject *)&Nature_Type);
+
+	// VertexNature
+	tmp = PyInt_FromLong( Nature::POINT ); PyDict_SetItemString( Nature_Type.tp_dict, "POINT", tmp); Py_DECREF(tmp);
+	tmp = PyInt_FromLong( Nature::S_VERTEX ); PyDict_SetItemString( Nature_Type.tp_dict, "S_VERTEX", tmp); Py_DECREF(tmp);
+	tmp = PyInt_FromLong( Nature::VIEW_VERTEX ); PyDict_SetItemString( Nature_Type.tp_dict, "VIEW_VERTEX", tmp); Py_DECREF(tmp);
+	tmp = PyInt_FromLong( Nature::NON_T_VERTEX ); PyDict_SetItemString( Nature_Type.tp_dict, "NON_T_VERTEX", tmp); Py_DECREF(tmp);
+	tmp = PyInt_FromLong( Nature::T_VERTEX ); PyDict_SetItemString( Nature_Type.tp_dict, "T_VERTEX", tmp); Py_DECREF(tmp);
+	tmp = PyInt_FromLong( Nature::CUSP ); PyDict_SetItemString( Nature_Type.tp_dict, "CUSP", tmp); Py_DECREF(tmp);
+	
+	// EdgeNature
+	tmp = BPy_Nature_from_Nature( Nature::NO_FEATURE ); PyDict_SetItemString( Nature_Type.tp_dict, "NO_FEATURE", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::SILHOUETTE ); PyDict_SetItemString( Nature_Type.tp_dict, "SILHOUETTE", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::BORDER ); PyDict_SetItemString( Nature_Type.tp_dict, "BORDER", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::CREASE ); PyDict_SetItemString( Nature_Type.tp_dict, "CREASE", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::RIDGE ); PyDict_SetItemString( Nature_Type.tp_dict, "RIDGE", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::VALLEY ); PyDict_SetItemString( Nature_Type.tp_dict, "VALLEY", tmp); Py_DECREF(tmp);
+	tmp = BPy_Nature_from_Nature( Nature::SUGGESTIVE_CONTOUR ); PyDict_SetItemString( Nature_Type.tp_dict, "SUGGESTIVE_CONTOUR", tmp); Py_DECREF(tmp);
+	
+}
+
+int Nature___init__(BPy_Nature *self, PyObject *args, PyObject *kwds)
+{
+    if (PyInt_Type.tp_init((PyObject *)self, args, kwds) < 0)
+        return -1;
+	
+	return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/Nature.h b/source/blender/freestyle/intern/python/Nature.h
new file mode 100644
index 00000000000..7473869158f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Nature.h
@@ -0,0 +1,33 @@
+#ifndef FREESTYLE_PYTHON_NATURE_H
+#define FREESTYLE_PYTHON_NATURE_H
+
+#include "../winged_edge/Nature.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject Nature_Type;
+
+#define BPy_Nature_Check(v)	(( (PyObject *) v)->ob_type == &Nature_Type)
+
+/*---------------------------Python BPy_Nature structure definition----------*/
+typedef struct {
+	PyIntObject i;
+} BPy_Nature;
+
+/*---------------------------Python BPy_Nature visible prototypes-----------*/
+
+PyMODINIT_FUNC Nature_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_NATURE_H */
diff --git a/source/blender/freestyle/intern/python/Noise.cpp b/source/blender/freestyle/intern/python/Noise.cpp
new file mode 100644
index 00000000000..8e6b7aa5022
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Noise.cpp
@@ -0,0 +1,48 @@
+ PyObject *_wrap_Noise_turbulence1__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence1__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence1(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence2__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence2__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence2(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence3__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence3__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_turbulence3(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_smoothNoise1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_smoothNoise2(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Noise_smoothNoise3(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/Operators.cpp b/source/blender/freestyle/intern/python/Operators.cpp
new file mode 100644
index 00000000000..efae258d5ee
--- /dev/null
+++ b/source/blender/freestyle/intern/python/Operators.cpp
@@ -0,0 +1,57 @@
+PyObject *Operators_select(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_chain(PyObject *self, PyObject *args) {
+}
+
+
+PyObject *Operators_bidirectionalChain(PyObject *self, PyObject *args) {
+}
+
+
+PyObject *Operators_sequentialSplit(PyObject *self, PyObject *args) {
+}
+
+
+PyObject *Operators_recursiveSplit(PyObject *self, PyObject *args) {
+}
+
+
+PyObject *Operators_sort(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_create(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_getViewEdgeFromIndex(PyObject *self , PyObject *args) {
+
+}
+
+
+PyObject *Operators_getChainFromIndex(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_getStrokeFromIndex(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_getViewEdgesSize(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_getChainsSize(PyObject *self , PyObject *args) {
+}
+
+
+PyObject *Operators_getStrokesSize(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *delete_Operators(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/SShape.cpp b/source/blender/freestyle/intern/python/SShape.cpp
new file mode 100644
index 00000000000..a5b1cf3f27a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/SShape.cpp
@@ -0,0 +1,120 @@
+ PyObject *_wrap_SShape_userdata_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_userdata_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_SShape__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_SShape__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_SShape(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_dupplicate(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_SShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_AddEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_AddNewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_AddChain(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_CreateSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SplitEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SplitEdgeIn2(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SetBBox(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_ComputeBBox(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_RemoveEdgeFromChain(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_RemoveEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_GetVertexList(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_GetEdgeList(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_GetChains(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_bbox(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_material(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_materials(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_viewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_importance(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SetId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SetMaterials(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SetViewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_SShape_SetImportance(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeAttribute.cpp b/source/blender/freestyle/intern/python/StrokeAttribute.cpp
new file mode 100644
index 00000000000..b9f37dfa165
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeAttribute.cpp
@@ -0,0 +1,468 @@
+#include "StrokeAttribute.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for StrokeAttribute instance  -----------*/
+static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds);
+static void StrokeAttribute___dealloc__(BPy_StrokeAttribute *self);
+static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute *self);
+
+static PyObject * StrokeAttribute_getColorR( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getColorG( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getColorB( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getAlpha( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_isVisible( BPy_StrokeAttribute *self );
+static PyObject * StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
+static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
+
+
+/*----------------------StrokeAttribute instance definitions ----------------------------*/
+static PyMethodDef BPy_StrokeAttribute_methods[] = {
+	{"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, "Returns the R color component. "},
+	{"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, "Returns the G color component. "},
+	{"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, "Returns the B color component. "},
+	{"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, "Returns the RGB color components."},
+	{"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, "Returns the alpha color component."},
+	{"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, "Returns the thickness on the right of the vertex when following the stroke. "},
+	{"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, "Returns the thickness on the left of the vertex when following the stroke."},
+	{"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, "Returns the thickness on the right and on the left of the vertex when following the stroke. "},
+	{"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, "Returns true if the strokevertex is visible, false otherwise"},
+	{"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, "(name) Returns an attribute of type real specified by name."},
+	{"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, "(name) Returns an attribute of type Vec2f specified by name."},
+	{"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, "(name) Returns an attribute of type Vec3f specified by name."},
+	{"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, "(name) Checks whether the real attribute specified by name is available"},
+	{"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, "(name) Checks whether the Vec2f attribute specified by name is available"},
+	{"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, "(name) Checks whether the Vec3f attribute specified by name is available"},
+	{"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, "(float a)Sets the attribute's alpha value. "},
+	{"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, "(float a) Sets the attribute's alpha value."},
+	{"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, ""},
+	{"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, ""},
+	{"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, "(name, float att) Adds a user defined attribute of type real. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
+	{"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec2f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
+	{"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec4f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
+	{NULL, NULL, 0, NULL}
+};
+
+
+
+/*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
+
+PyTypeObject StrokeAttribute_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"StrokeAttribute",				/* tp_name */
+	sizeof( BPy_StrokeAttribute ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)StrokeAttribute___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)StrokeAttribute___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_StrokeAttribute_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,  							/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)StrokeAttribute___init__,                       	/* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 StrokeAttribute_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &StrokeAttribute_Type ) < 0 )
+		return;
+	Py_INCREF( &StrokeAttribute_Type );
+	PyModule_AddObject(module, "StrokeAttribute", (PyObject *)&StrokeAttribute_Type);
+	
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
+{
+
+	PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0, *obj4 = 0, *obj5 = 0 , *obj6 = 0;
+
+    if (! PyArg_ParseTuple(args, "|OOOOOO", &obj1, &obj2, &obj3, &obj4, &obj5, &obj6) )
+        return -1;
+
+	if( !obj1 || !obj2 || !obj3 ){
+		
+		self->sa = new StrokeAttribute();
+		
+	} else if( 	BPy_StrokeAttribute_Check(obj1) && 
+				BPy_StrokeAttribute_Check(obj2) &&
+				PyFloat_Check(obj3) ) {	
+		
+			self->sa = new StrokeAttribute(	*( ((BPy_StrokeAttribute *) obj1)->sa ),
+											*( ((BPy_StrokeAttribute *) obj2)->sa ),
+											PyFloat_AsDouble( obj3 ) );	
+										
+	} else if( 	obj4 && obj5 && obj6 ) {
+	
+			self->sa = new StrokeAttribute(	PyFloat_AsDouble( obj1 ),
+											PyFloat_AsDouble( obj2 ),
+											PyFloat_AsDouble( obj3 ),
+											PyFloat_AsDouble( obj4 ),
+											PyFloat_AsDouble( obj5 ),
+											PyFloat_AsDouble( obj6 ) );
+
+	} else {
+		return -1;
+	}
+
+
+	return 0;
+
+}
+
+void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
+{
+	delete self->sa;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
+{
+	stringstream repr("StrokeAttribute:");
+	repr << " r: " << self->sa->getColorR()
+		 << " g: " << self->sa->getColorG()
+		 << " b: " << self->sa->getColorB()
+		 << " a: " << self->sa->getAlpha()
+		 << " - R: " << self->sa->getThicknessR() 
+		 << " L: " << self->sa->getThicknessL();
+
+	return PyString_FromFormat( repr.str().c_str() );
+}
+
+
+PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getColorR() );	
+}
+
+PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getColorG() );	
+}
+
+PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getColorB() );	
+}
+
+PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
+	Vec3f v( self->sa->getColorRGB() );
+	return Vector_from_Vec3f( v );	
+}
+
+PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getAlpha() );	
+}
+
+PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getThicknessR() );	
+}
+PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
+	return PyFloat_FromDouble( self->sa->getThicknessL() );	
+}
+PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
+	Vec2f v( self->sa->getThicknessRL() );
+	return Vector_from_Vec2f( v );
+}
+
+PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
+	return PyBool_from_bool( self->sa->isVisible() );	
+}
+
+
+PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_getAttributeReal" << endl;
+		Py_RETURN_NONE;
+	}
+
+	double a = self->sa->getAttributeReal( attr );
+	return PyFloat_FromDouble( a );
+}
+
+PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_getAttributeVec2f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	Vec2f a = self->sa->getAttributeVec2f( attr );
+	return Vector_from_Vec2f( a );
+}
+
+
+PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_getAttributeVec3f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	Vec3f a = self->sa->getAttributeVec3f( attr );
+	return Vector_from_Vec3f( a );
+}
+
+PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_isAttributeAvailableReal" << endl;
+		Py_RETURN_NONE;
+	}
+
+	return PyBool_from_bool( self->sa->isAttributeAvailableReal( attr ) );
+}
+
+PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_isAttributeAvailableVec2f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	return PyBool_from_bool( self->sa->isAttributeAvailableVec2f( attr ) );
+}
+
+PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *attr;
+
+	if(!( PyArg_ParseTuple(args, "s", &attr) )) {
+		cout << "ERROR: StrokeAttribute_isAttributeAvailableVec3f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	return PyBool_from_bool( self->sa->isAttributeAvailableVec3f( attr ) );
+}
+
+
+PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
+	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0 ;
+
+	if(!( PyArg_ParseTuple(args, "O|OO", &obj1, &obj2, &obj3) )) {
+		cout << "ERROR: StrokeAttribute_setColor" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	if( PyList_Check(obj1) && !obj2 && !obj3 ){
+		
+		Vec3f v( 	PyFloat_AsDouble( PyList_GetItem(obj1, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj1, 1) ),
+					PyFloat_AsDouble( PyList_GetItem(obj1, 2) )  );
+		
+		self->sa->setColor( v );
+		
+	} else if( 	obj1 && obj2 && obj3 ){
+
+		self->sa->setColor(	PyFloat_AsDouble(obj1),
+							PyFloat_AsDouble(obj2),
+							PyFloat_AsDouble(obj3) );
+	}
+	
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
+	float f = 0;
+
+	if(!( PyArg_ParseTuple(args, "f", &f) )) {
+		cout << "ERROR: StrokeAttribute_setAlpha" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	self->sa->setAlpha( f );
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
+	PyObject *obj1 = 0, *obj2 = 0;
+
+	if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) )) {
+		cout << "ERROR: StrokeAttribute_setThickness" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( PyList_Check(obj1) && !obj2 ){
+		
+		Vec2f v( 	PyFloat_AsDouble( PyList_GetItem(obj1, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj1, 1) )  );
+		
+		self->sa->setThickness( v );
+		
+	} else if( 	obj1 && obj2 ){
+					
+		self->sa->setThickness(	PyFloat_AsDouble(obj1),
+								PyFloat_AsDouble(obj2) );
+	}
+	
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
+	int i = 0;
+
+	if(!( PyArg_ParseTuple(args, "i", &i) )) {
+		cout << "ERROR: StrokeAttribute_setVisible" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sa->setVisible( i );
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *s = 0;
+	double d = 0;
+
+	if(!( PyArg_ParseTuple(args, "sd", &s, &d) )) {
+		cout << "ERROR: StrokeAttribute_setAttributeReal" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sa->setAttributeReal( s, d );
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *s;
+	PyObject *obj = 0;
+
+	if(!( PyArg_ParseTuple(args, "sO", &s, &obj) )) {
+		cout << "ERROR: StrokeAttribute_setAttributeVec2f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( PyList_Check(obj) && PyList_Size(obj) > 1) {
+
+		Vec2f v( 	PyFloat_AsDouble( PyList_GetItem(obj, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj, 1) )  );
+
+		self->sa->setAttributeVec2f( s, v );
+	}
+	
+	Py_RETURN_NONE;
+}
+
+PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+	char *s;
+	PyObject *obj = 0;
+
+	if(!( PyArg_ParseTuple(args, "sO", &s, &obj) )) {
+		cout << "ERROR: StrokeAttribute_setAttributeVec3f" << endl;
+		Py_RETURN_NONE;
+	}
+
+	if( PyList_Check(obj)  && PyList_Size(obj) > 2 ) {
+
+		Vec3f v( 	PyFloat_AsDouble( PyList_GetItem(obj, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj, 1) ),
+					PyFloat_AsDouble( PyList_GetItem(obj, 2) )  );
+
+		self->sa->setAttributeVec3f( s, v );
+	}
+
+	Py_RETURN_NONE;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/source/blender/freestyle/intern/python/StrokeAttribute.h b/source/blender/freestyle/intern/python/StrokeAttribute.h
new file mode 100644
index 00000000000..a0828e4f668
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeAttribute.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_STROKEATTRIBUTE_H
+#define FREESTYLE_PYTHON_STROKEATTRIBUTE_H
+
+#include "../stroke/Stroke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject StrokeAttribute_Type;
+
+#define BPy_StrokeAttribute_Check(v)	(( (PyObject *) v)->ob_type == &StrokeAttribute_Type)
+
+/*---------------------------Python BPy_StrokeAttribute structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	StrokeAttribute *sa;
+} BPy_StrokeAttribute;
+
+/*---------------------------Python BPy_StrokeAttribute visible prototypes-----------*/
+
+PyMODINIT_FUNC StrokeAttribute_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_STROKEATTRIBUTE_H */
diff --git a/source/blender/freestyle/intern/python/StrokeShader.cpp b/source/blender/freestyle/intern/python/StrokeShader.cpp
new file mode 100644
index 00000000000..029f8776c73
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader.cpp
@@ -0,0 +1,170 @@
+#include "StrokeShader.h"
+
+#include "Convert.h"
+#include "Interface1D/Stroke.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for StrokeShader instance  -----------*/
+static int StrokeShader___init__(BPy_StrokeShader *self, PyObject *args, PyObject *kwds);
+static void StrokeShader___dealloc__(BPy_StrokeShader *self);
+static PyObject * StrokeShader___repr__(BPy_StrokeShader *self);
+
+static PyObject * StrokeShader_getName( BPy_StrokeShader *self, PyObject *args);
+static PyObject * StrokeShader_shade( BPy_StrokeShader *self , PyObject *args);
+
+/*----------------------StrokeShader instance definitions ----------------------------*/
+static PyMethodDef BPy_StrokeShader_methods[] = {
+	{"getName", ( PyCFunction ) StrokeShader_getName, METH_NOARGS, "（ ）Returns the string of the name of the binary predicate."},
+	{"shade", ( PyCFunction ) StrokeShader_shade, METH_VARARGS, "（Stroke s ）The shading method. This method must be overloaded by inherited classes. The shading method is designed to modify any Stroke's attribute such as Thickness, Color, Geometry, Texture, Blending mode... The basic way to achieve this operation consists in iterating over the StrokeVertices of the Stroke and to modify each one's StrokeAttribute."},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_StrokeShader type definition ------------------------------*/
+
+PyTypeObject StrokeShader_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"StrokeShader",				/* tp_name */
+	sizeof( BPy_StrokeShader ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)StrokeShader___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)StrokeShader___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_StrokeShader_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)StrokeShader___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 StrokeShader_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &StrokeShader_Type ) < 0 )
+		return;
+
+	Py_INCREF( &StrokeShader_Type );
+	PyModule_AddObject(module, "StrokeShader", (PyObject *)&StrokeShader_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int StrokeShader___init__(BPy_StrokeShader *self, PyObject *args, PyObject *kwds)
+{
+	self->ss = new StrokeShader();
+	return 0;
+}
+
+void StrokeShader___dealloc__(BPy_StrokeShader* self)
+{
+	delete self->ss;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+
+PyObject * StrokeShader___repr__(BPy_StrokeShader* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->ss->getName().c_str(), self->ss );
+}
+
+
+PyObject * StrokeShader_getName( BPy_StrokeShader *self, PyObject *args)
+{
+	return PyString_FromString( self->ss->getName().c_str() );
+}
+
+PyObject *StrokeShader_shade( BPy_StrokeShader *self , PyObject *args) {
+	PyObject *py_s = 0;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_s) && BPy_Stroke_Check(py_s) )) {
+		cout << "ERROR: StrokeShader_shade" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	self->ss->shade(*( ((BPy_Stroke *) py_s)->s ));
+
+	Py_RETURN_NONE;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/StrokeShader.h b/source/blender/freestyle/intern/python/StrokeShader.h
new file mode 100644
index 00000000000..091eaa50383
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader.h
@@ -0,0 +1,41 @@
+#ifndef FREESTYLE_PYTHON_STROKESHADER_H
+#define FREESTYLE_PYTHON_STROKESHADER_H
+
+
+#include "../system/FreestyleConfig.h"
+
+using namespace std;
+
+#include "../stroke/StrokeShader.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject StrokeShader_Type;
+
+#define BPy_StrokeShader_Check(v)	(( (PyObject *) v)->ob_type == &StrokeShader_Type)
+
+/*---------------------------Python BPy_StrokeShader structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	StrokeShader *ss;
+} BPy_StrokeShader;
+
+/*---------------------------Python BPy_StrokeShader visible prototypes-----------*/
+
+PyMODINIT_FUNC StrokeShader_Init( PyObject *module );
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* FREESTYLE_PYTHON_STROKESHADER_H */
diff --git a/source/blender/freestyle/intern/python/StrokeShader/BackboneStretcherShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/BackboneStretcherShader.cpp
new file mode 100644
index 00000000000..96fd31e982e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/BackboneStretcherShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_BackboneStretcherShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_BackboneStretcherShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/BezierCurveShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/BezierCurveShader.cpp
new file mode 100644
index 00000000000..a4d476bb2d6
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/BezierCurveShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_BezierCurveShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_BezierCurveShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/CalligraphicShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/CalligraphicShader.cpp
new file mode 100644
index 00000000000..2f7a422d311
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/CalligraphicShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_CalligraphicShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ColorNoiseShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ColorNoiseShader.cpp
new file mode 100644
index 00000000000..1b52e33fd8f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ColorNoiseShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_ColorNoiseShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ColorNoiseShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ColorVariationPatternShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ColorVariationPatternShader.cpp
new file mode 100644
index 00000000000..7529c869939
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ColorVariationPatternShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_ColorVariationPatternShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ConstantColorShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ConstantColorShader.cpp
new file mode 100644
index 00000000000..e636331c57c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ConstantColorShader.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ConstantColorShader_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ConstantColorShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ConstantColorShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ConstantThicknessShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ConstantThicknessShader.cpp
new file mode 100644
index 00000000000..1840ef71f6d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ConstantThicknessShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_ConstantThicknessShader_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ConstantThicknessShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ConstrainedIncreasingThicknessShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ConstrainedIncreasingThicknessShader.cpp
new file mode 100644
index 00000000000..41eb1c94d17
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ConstrainedIncreasingThicknessShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_ConstrainedIncreasingThicknessShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/GuidingLinesShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/GuidingLinesShader.cpp
new file mode 100644
index 00000000000..633523af330
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/GuidingLinesShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_GuidingLinesShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GuidingLinesShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/IncreasingColorShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/IncreasingColorShader.cpp
new file mode 100644
index 00000000000..2fbb74f3768
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/IncreasingColorShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_IncreasingColorShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_IncreasingColorShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/IncreasingThicknessShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/IncreasingThicknessShader.cpp
new file mode 100644
index 00000000000..4d97f43841d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/IncreasingThicknessShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_IncreasingThicknessShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/PolygonalizationShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/PolygonalizationShader.cpp
new file mode 100644
index 00000000000..098330d37bd
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/PolygonalizationShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_PolygonalizationShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_PolygonalizationShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/SamplingShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/SamplingShader.cpp
new file mode 100644
index 00000000000..3a42bda3b08
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/SamplingShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_SamplingShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_SamplingShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/SpatialNoiseShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/SpatialNoiseShader.cpp
new file mode 100644
index 00000000000..ff90e7f973c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/SpatialNoiseShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_SpatialNoiseShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/StrokeTextureShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/StrokeTextureShader.cpp
new file mode 100644
index 00000000000..90636eb5aee
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/StrokeTextureShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_StrokeTextureShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_StrokeTextureShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/TextureAssignerShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/TextureAssignerShader.cpp
new file mode 100644
index 00000000000..9a308d60ac3
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/TextureAssignerShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_TextureAssignerShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TextureAssignerShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ThicknessNoiseShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ThicknessNoiseShader.cpp
new file mode 100644
index 00000000000..0c69aa5cfc1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ThicknessNoiseShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_ThicknessNoiseShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ThicknessNoiseShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/ThicknessVariationPatternShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/ThicknessVariationPatternShader.cpp
new file mode 100644
index 00000000000..02326259be8
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/ThicknessVariationPatternShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_ThicknessVariationPatternShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/TipRemoverShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/TipRemoverShader.cpp
new file mode 100644
index 00000000000..4a202ddd6ee
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/TipRemoverShader.cpp
@@ -0,0 +1,4 @@
+ PyObject *_wrap_TipRemoverShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/fstreamShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/fstreamShader.cpp
new file mode 100644
index 00000000000..dc19cde3871
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/fstreamShader.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_fstreamShader_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_fstreamShader_shade(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeShader/streamShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/streamShader.cpp
new file mode 100644
index 00000000000..aa3250f858c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeShader/streamShader.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_streamShader_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_streamShader_shade(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_streamShader(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/StrokeVertexIterator.cpp b/source/blender/freestyle/intern/python/StrokeVertexIterator.cpp
new file mode 100644
index 00000000000..3fae5a34060
--- /dev/null
+++ b/source/blender/freestyle/intern/python/StrokeVertexIterator.cpp
@@ -0,0 +1,260 @@
+ PyObject *_wrap_StrokeVertexIterator_castToInterface0DIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getObject(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator___deref__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_increment(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_decrement(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_isBegin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_isEnd(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator___eq__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_t(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_u(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_copy(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getIt(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_x(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_y(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getPoint(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_attribute__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_attribute__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_attribute(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_curvilinearAbscissa(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_strokeLength(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetPoint__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetPoint__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetPoint(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetAttribute(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetCurvilinearAbscissa(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetStrokeLength(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getPoint3D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getProjectedX(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getProjectedY(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getProjectedZ(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getPoint2D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getFEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_getNature(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_castToSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_castToViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_castToNonTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_castToTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_A(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_B(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_t2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetA(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetB(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_SetT2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_fedge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_point2d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_point3d(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_normal(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occluders_begin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occluders_end(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occluders_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occluders_size(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occludee(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occluded_shape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_occludee_empty(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_z_discontinuity(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_curvatureFredo(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_StrokeVertexIterator_directionFredo(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D.cpp
new file mode 100644
index 00000000000..b9da3dfc20d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D.cpp
@@ -0,0 +1,173 @@
+#include "UnaryFunction0D.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryFunction0D instance  -----------*/
+static int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds);
+static void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D *self);
+static PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D *self);
+
+static PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args);
+static PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args);
+
+/*----------------------UnaryFunction0D instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryFunction0D_methods[] = {
+	{"getName", ( PyCFunction ) UnaryFunction0D_getName, METH_NOARGS, ""},
+	{"__call__", ( PyCFunction ) UnaryFunction0D___call__, METH_VARARGS, "" },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryFunction0D type definition ------------------------------*/
+
+PyTypeObject UnaryFunction0D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction0D",				/* tp_name */
+	sizeof( BPy_UnaryFunction0D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction0D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction0D___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_UnaryFunction0D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction0D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 UnaryFunction0D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction0D_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction0D_Type );
+	PyModule_AddObject(module, "UnaryFunction0D", (PyObject *)&UnaryFunction0D_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds)
+{
+	return 0;
+}
+
+void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D* self)
+{
+	//delete self->uf0D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+
+PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction0D<void> *) self->uf0D)->getName().c_str(), self->uf0D );
+}
+
+
+PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args)
+{
+	return PyString_FromString( ((UnaryFunction0D<void> *) self->uf0D)->getName().c_str() );
+}
+
+PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args)
+{
+	PyObject *l;
+
+	if( !PyArg_ParseTuple(args, "O", &l) ) {
+		cout << "ERROR: UnaryFunction0D___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;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D.h b/source/blender/freestyle/intern/python/UnaryFunction0D.h
new file mode 100644
index 00000000000..8f1935871ca
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION0D_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION0D_H
+
+#include "../view_map/Functions0D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction0D_Type;
+
+#define BPy_UnaryFunction0D_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction0D_Type)
+
+/*---------------------------Python BPy_UnaryFunction0D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	void *uf0D;
+} BPy_UnaryFunction0D;
+
+/*---------------------------Python BPy_UnaryFunction0D visible prototypes-----------*/
+
+PyMODINIT_FUNC UnaryFunction0D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION0D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DDouble.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DDouble.cpp
new file mode 100644
index 00000000000..df286794dd3
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DDouble.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DDouble_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DDouble___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DDouble(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DFloat.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DFloat.cpp
new file mode 100644
index 00000000000..ccb89d91ecf
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DFloat.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DFloat_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DFloat___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DFloat(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DId.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DId.cpp
new file mode 100644
index 00000000000..b854b3ccaa4
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DId.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DId_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DId___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DId(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DUnsigned.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DUnsigned.cpp
new file mode 100644
index 00000000000..425d1cdabf5
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DUnsigned.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DUnsigned_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DUnsigned___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DUnsigned(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec2f.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec2f.cpp
new file mode 100644
index 00000000000..828d39b6de7
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec2f.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DVec2f_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DVec2f___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DVec2f(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec3f.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec3f.cpp
new file mode 100644
index 00000000000..b6a6d0264bc
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVec3f.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_UnaryFunction0DVec3f_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DVec3f___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction0DVec3f(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVectorViewShape.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVectorViewShape.cpp
new file mode 100644
index 00000000000..f9736680ab8
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DVectorViewShape.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_UnaryFunction0DVectorViewShape_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DVectorViewShape___call__(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DViewShape.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DViewShape.cpp
new file mode 100644
index 00000000000..3dddb333a55
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0DViewShape.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_UnaryFunction0DViewShape_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction0DViewShape___call__(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/ShapeIdF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/ShapeIdF0D.cpp
new file mode 100644
index 00000000000..58fa20b8e95
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/ShapeIdF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ShapeIdF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ShapeIdF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ShapeIdF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ShapeIdF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/MaterialF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/MaterialF0D.cpp
new file mode 100644
index 00000000000..167a68b8977
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/MaterialF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_MaterialF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_MaterialF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_MaterialF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_MaterialF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/CurveNatureF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/CurveNatureF0D.cpp
new file mode 100644
index 00000000000..1b155757589
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/CurveNatureF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_CurveNatureF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurveNatureF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_CurveNatureF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_CurveNatureF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/Normal2DF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/Normal2DF0D.cpp
new file mode 100644
index 00000000000..99f892529ab
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/Normal2DF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_Normal2DF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Normal2DF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_Normal2DF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Normal2DF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/VertexOrientation2DF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/VertexOrientation2DF0D.cpp
new file mode 100644
index 00000000000..bf7fbfe2550
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/VertexOrientation2DF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_VertexOrientation2DF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_VertexOrientation2DF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_VertexOrientation2DF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_VertexOrientation2DF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/VertexOrientation3DF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/VertexOrientation3DF0D.cpp
new file mode 100644
index 00000000000..32d5ac529fa
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/VertexOrientation3DF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_VertexOrientation3DF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_VertexOrientation3DF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_VertexOrientation3DF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_VertexOrientation3DF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetOccludeeF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetOccludeeF0D.cpp
new file mode 100644
index 00000000000..2dc779a3fdb
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetOccludeeF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetOccludeeF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetOccludeeF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetOccludeeF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetOccludeeF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetShapeF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetShapeF0D.cpp
new file mode 100644
index 00000000000..92ec79efec5
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/GetShapeF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetShapeF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetShapeF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetShapeF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetShapeF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/DensityF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/DensityF0D.cpp
new file mode 100644
index 00000000000..50986360f2c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/DensityF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_DensityF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_DensityF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_DensityF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/LocalAverageDepthF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/LocalAverageDepthF0D.cpp
new file mode 100644
index 00000000000..0738f2cf6dc
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/LocalAverageDepthF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_LocalAverageDepthF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_LocalAverageDepthF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_LocalAverageDepthF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetCurvilinearAbscissaF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetCurvilinearAbscissaF0D.cpp
new file mode 100644
index 00000000000..359e3186905
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetCurvilinearAbscissaF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetCurvilinearAbscissaF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetCurvilinearAbscissaF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetCurvilinearAbscissaF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetCurvilinearAbscissaF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetParameterF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetParameterF0D.cpp
new file mode 100644
index 00000000000..71b7ac85a7f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetParameterF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetParameterF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetParameterF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetParameterF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetParameterF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetViewMapGradientNormF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetViewMapGradientNormF0D.cpp
new file mode 100644
index 00000000000..8def0ea948f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/GetViewMapGradientNormF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetViewMapGradientNormF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetViewMapGradientNormF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetViewMapGradientNormF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadCompleteViewMapPixelF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadCompleteViewMapPixelF0D.cpp
new file mode 100644
index 00000000000..74fdf60dffc
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadCompleteViewMapPixelF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ReadCompleteViewMapPixelF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ReadCompleteViewMapPixelF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ReadCompleteViewMapPixelF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadMapPixelF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadMapPixelF0D.cpp
new file mode 100644
index 00000000000..cb2bdd4c60a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadMapPixelF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ReadMapPixelF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ReadMapPixelF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ReadMapPixelF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadSteerableViewMapPixelF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadSteerableViewMapPixelF0D.cpp
new file mode 100644
index 00000000000..dc32cf290a0
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/ReadSteerableViewMapPixelF0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ReadSteerableViewMapPixelF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ReadSteerableViewMapPixelF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ReadSteerableViewMapPixelF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/Curvature2DAngleF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/Curvature2DAngleF0D.cpp
new file mode 100644
index 00000000000..f91642ad7c1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/Curvature2DAngleF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_Curvature2DAngleF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Curvature2DAngleF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_Curvature2DAngleF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Curvature2DAngleF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedXF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedXF0D.cpp
new file mode 100644
index 00000000000..f99666cdd65
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedXF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetProjectedXF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetProjectedXF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetProjectedXF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetProjectedXF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedYF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedYF0D.cpp
new file mode 100644
index 00000000000..44eb1d44bf2
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedYF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetProjectedYF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetProjectedYF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetProjectedYF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetProjectedYF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedZF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedZF0D.cpp
new file mode 100644
index 00000000000..0257328973b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetProjectedZF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetProjectedZF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetProjectedZF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetProjectedZF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetProjectedZF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetXF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetXF0D.cpp
new file mode 100644
index 00000000000..6bc16ad36d1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetXF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetXF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetXF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetXF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetXF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetYF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetYF0D.cpp
new file mode 100644
index 00000000000..c2651fc59be
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetYF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetYF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetYF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetYF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetYF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetZF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetZF0D.cpp
new file mode 100644
index 00000000000..e3f1f56a932
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/GetZF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetZF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetZF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetZF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetZF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/ZDiscontinuityF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/ZDiscontinuityF0D.cpp
new file mode 100644
index 00000000000..c72e020066a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_real/ZDiscontinuityF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ZDiscontinuityF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ZDiscontinuityF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ZDiscontinuityF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ZDiscontinuityF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/QuantitativeInvisibilityF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/QuantitativeInvisibilityF0D.cpp
new file mode 100644
index 00000000000..15e3114b81a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/QuantitativeInvisibilityF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_QuantitativeInvisibilityF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_QuantitativeInvisibilityF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_QuantitativeInvisibilityF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_QuantitativeInvisibilityF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_vector_ViewShape/GetOccludersF0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_vector_ViewShape/GetOccludersF0D.cpp
new file mode 100644
index 00000000000..95de61007c1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_vector_ViewShape/GetOccludersF0D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_GetOccludersF0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetOccludersF0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_GetOccludersF0D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetOccludersF0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D.cpp
new file mode 100644
index 00000000000..db026ced338
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D.cpp
@@ -0,0 +1,175 @@
+#include "UnaryFunction1D.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  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}
+};
+
+/*-----------------------BPy_UnaryFunction1D type definition ------------------------------*/
+
+PyTypeObject UnaryFunction1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryFunction1D",				/* tp_name */
+	sizeof( BPy_UnaryFunction1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryFunction1D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryFunction1D___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 ***/
+	NULL,                          /* long tp_weaklistoffset; */
+
+  /*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+  /*** Attribute descriptor and subclassing stuff ***/
+	BPy_UnaryFunction1D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	NULL,                          	/* long tp_dictoffset; */
+	(initproc)UnaryFunction1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 UnaryFunction1D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryFunction1D_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryFunction1D_Type );
+	PyModule_AddObject(module, "UnaryFunction1D", (PyObject *)&UnaryFunction1D_Type);
+}
+
+//------------------------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() );
+}
+
+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
+}
+#endif
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D.h
new file mode 100644
index 00000000000..4c509f50b85
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1D_H
+#define FREESTYLE_PYTHON_UNARYFUNCTION1D_H
+
+#include "../view_map/Functions1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryFunction1D_Type;
+
+#define BPy_UnaryFunction1D_Check(v)	(( (PyObject *) v)->ob_type == &UnaryFunction1D_Type)
+
+/*---------------------------Python BPy_UnaryFunction1D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+ 	void *uf1D;
+} BPy_UnaryFunction1D;
+
+/*---------------------------Python BPy_UnaryFunction1D visible prototypes-----------*/
+
+PyMODINIT_FUNC UnaryFunction1D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DDouble.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DDouble.cpp
new file mode 100644
index 00000000000..ad7c6627799
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DDouble.cpp
@@ -0,0 +1,20 @@
+ PyObject *_wrap_UnaryFunction1DDouble_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DDouble___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DDouble_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DDouble_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction1DDouble(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DFloat.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DFloat.cpp
new file mode 100644
index 00000000000..cb572980f8f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DFloat.cpp
@@ -0,0 +1,20 @@
+ PyObject *_wrap_UnaryFunction1DFloat_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DFloat___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DFloat_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DFloat_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction1DFloat(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DUnsigned.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DUnsigned.cpp
new file mode 100644
index 00000000000..eb230a2d49f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DUnsigned.cpp
@@ -0,0 +1,20 @@
+ PyObject *_wrap_UnaryFunction1DUnsigned_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DUnsigned___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DUnsigned_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DUnsigned_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction1DUnsigned(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec2f.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec2f.cpp
new file mode 100644
index 00000000000..64fb6ef6ed7
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec2f.cpp
@@ -0,0 +1,20 @@
+ PyObject *_wrap_UnaryFunction1DVec2f_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec2f___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec2f_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec2f_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction1DVec2f(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec3f.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec3f.cpp
new file mode 100644
index 00000000000..d7b360eb10e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVec3f.cpp
@@ -0,0 +1,20 @@
+ PyObject *_wrap_UnaryFunction1DVec3f_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec3f___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec3f_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVec3f_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_UnaryFunction1DVec3f(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVectorViewShape.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVectorViewShape.cpp
new file mode 100644
index 00000000000..1fe16797593
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1DVectorViewShape.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_UnaryFunction1DVectorViewShape_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVectorViewShape___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVectorViewShape_setIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_UnaryFunction1DVectorViewShape_getIntegrationType(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/CurveNatureF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/CurveNatureF1D.cpp
new file mode 100644
index 00000000000..94d180e6cc8
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/CurveNatureF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_CurveNatureF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_CurveNatureF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_CurveNatureF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Normal2DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Normal2DF1D.cpp
new file mode 100644
index 00000000000..81e5a18cb2c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Normal2DF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_Normal2DF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Normal2DF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Normal2DF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Orientation2DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Orientation2DF1D.cpp
new file mode 100644
index 00000000000..2d6cfed8575
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/Orientation2DF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_Orientation2DF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Orientation2DF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Orientation2DF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/Orientation3DF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/Orientation3DF1D.cpp
new file mode 100644
index 00000000000..f416f2ace03
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/Orientation3DF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_Orientation3DF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_Orientation3DF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_Orientation3DF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/DensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/DensityF1D.cpp
new file mode 100644
index 00000000000..861a94b7cd3
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/DensityF1D.cpp
@@ -0,0 +1,8 @@
+ PyObject *_wrap_DensityF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_DensityF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetCompleteViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetCompleteViewMapDensityF1D.cpp
new file mode 100644
index 00000000000..c8220604cb8
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetCompleteViewMapDensityF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetCompleteViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetCompleteViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetCompleteViewMapDensityF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetDirectionalViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetDirectionalViewMapDensityF1D.cpp
new file mode 100644
index 00000000000..b7c4e40fd82
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/GetDirectionalViewMapDensityF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetDirectionalViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetDirectionalViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetDirectionalViewMapDensityF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/LocalAverageDepthF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/LocalAverageDepthF1D.cpp
new file mode 100644
index 00000000000..6b9c687e9e0
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/LocalAverageDepthF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_LocalAverageDepthF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_LocalAverageDepthF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_LocalAverageDepthF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/Curvature2DAngleF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/Curvature2DAngleF1D.cpp
new file mode 100644
index 00000000000..d2057990944
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/Curvature2DAngleF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetProjectedXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedXF1D.cpp
new file mode 100644
index 00000000000..d7c8ace1bb2
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedXF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetProjectedYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedYF1D.cpp
new file mode 100644
index 00000000000..e567e07ba5a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedYF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetProjectedZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedZF1D.cpp
new file mode 100644
index 00000000000..b20ee1443e7
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetProjectedZF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetSteerableViewMapDensityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetSteerableViewMapDensityF1D.cpp
new file mode 100644
index 00000000000..21df4596b5e
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetSteerableViewMapDensityF1D.cpp
@@ -0,0 +1,8 @@
+ 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/GetViewMapGradientNormF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetViewMapGradientNormF1D.cpp
new file mode 100644
index 00000000000..bd5425450e8
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetViewMapGradientNormF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetXF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetXF1D.cpp
new file mode 100644
index 00000000000..73b4df64df6
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetXF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetYF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetYF1D.cpp
new file mode 100644
index 00000000000..36a1ffed9c6
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetYF1D.cpp
@@ -0,0 +1,12 @@
+ 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/GetZF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetZF1D.cpp
new file mode 100644
index 00000000000..ad0fc844a1c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/GetZF1D.cpp
@@ -0,0 +1,12 @@
+ 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/ZDiscontinuityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/ZDiscontinuityF1D.cpp
new file mode 100644
index 00000000000..886607f7ca9
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/ZDiscontinuityF1D.cpp
@@ -0,0 +1,12 @@
+ 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/QuantitativeInvisibilityF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/QuantitativeInvisibilityF1D.cpp
new file mode 100644
index 00000000000..436b617886b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/QuantitativeInvisibilityF1D.cpp
@@ -0,0 +1,12 @@
+ 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_vector_ViewShape/GetOccludeeF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetOccludeeF1D.cpp
new file mode 100644
index 00000000000..7df4ea835ca
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetOccludeeF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetOccludeeF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetOccludeeF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetOccludeeF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetOccludersF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetOccludersF1D.cpp
new file mode 100644
index 00000000000..26c14fc4a81
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetOccludersF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetOccludersF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetOccludersF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetOccludersF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetShapeF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetShapeF1D.cpp
new file mode 100644
index 00000000000..e1fd19d5d3b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/GetShapeF1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_GetShapeF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_GetShapeF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_GetShapeF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/ChainingTimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/ChainingTimeStampF1D.cpp
new file mode 100644
index 00000000000..daf3c773267
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/ChainingTimeStampF1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/IncrementChainingTimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/IncrementChainingTimeStampF1D.cpp
new file mode 100644
index 00000000000..291d180a3fe
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/IncrementChainingTimeStampF1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_IncrementChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_IncrementChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/TimeStampF1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/TimeStampF1D.cpp
new file mode 100644
index 00000000000..8df3b712a30
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/TimeStampF1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_TimeStampF1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TimeStampF1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_TimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TimeStampF1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp
new file mode 100644
index 00000000000..1d2fd6b284f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp
@@ -0,0 +1,170 @@
+#include "UnaryPredicate0D.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryPredicate0D instance  -----------*/
+static int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds);
+static void UnaryPredicate0D___dealloc__(BPy_UnaryPredicate0D *self);
+static PyObject * UnaryPredicate0D___repr__(BPy_UnaryPredicate0D *self);
+
+static PyObject * UnaryPredicate0D_getName( BPy_UnaryPredicate0D *self, PyObject *args);
+static PyObject * UnaryPredicate0D___call__( BPy_UnaryPredicate0D *self, PyObject *args);
+
+/*----------------------UnaryPredicate0D instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryPredicate0D_methods[] = {
+	{"getName", ( PyCFunction ) UnaryPredicate0D_getName, METH_NOARGS, ""},
+	{"__call__", ( PyCFunction ) UnaryPredicate0D___call__, METH_VARARGS, "" },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryPredicate0D type definition ------------------------------*/
+
+PyTypeObject UnaryPredicate0D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryPredicate0D",				/* tp_name */
+	sizeof( BPy_UnaryPredicate0D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryPredicate0D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryPredicate0D___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_UnaryPredicate0D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryPredicate0D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 UnaryPredicate0D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryPredicate0D_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryPredicate0D_Type );
+	PyModule_AddObject(module, "UnaryPredicate0D", (PyObject *)&UnaryPredicate0D_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds)
+{
+	return 0;
+}
+
+void UnaryPredicate0D___dealloc__(BPy_UnaryPredicate0D* self)
+{
+	delete self->up0D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+
+PyObject * UnaryPredicate0D___repr__(BPy_UnaryPredicate0D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->up0D->getName().c_str(), self->up0D );
+}
+
+
+PyObject * UnaryPredicate0D_getName( BPy_UnaryPredicate0D *self, PyObject *args)
+{
+	return PyString_FromString( self->up0D->getName().c_str() );
+}
+
+PyObject * UnaryPredicate0D___call__( BPy_UnaryPredicate0D *self, PyObject *args)
+{
+	PyObject *l;
+
+	if( !PyArg_ParseTuple(args, "O", &l) ) {
+		cout << "ERROR: UnaryPredicate0D___call__ " << endl;		
+		return NULL;
+	}
+	
+	//TBD
+	
+	Py_RETURN_NONE;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D.h b/source/blender/freestyle/intern/python/UnaryPredicate0D.h
new file mode 100644
index 00000000000..1f72ba5e86b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate0D.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYPREDICATE0D_H
+#define FREESTYLE_PYTHON_UNARYPREDICATE0D_H
+
+#include "../stroke/Predicates0D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryPredicate0D_Type;
+
+#define BPy_UnaryPredicate0D_Check(v)	(( (PyObject *) v)->ob_type == &UnaryPredicate0D_Type)
+
+/*---------------------------Python BPy_UnaryPredicate0D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	UnaryPredicate0D *up0D;
+} BPy_UnaryPredicate0D;
+
+/*---------------------------Python BPy_UnaryPredicate0D visible prototypes-----------*/
+
+PyMODINIT_FUNC UnaryPredicate0D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYPREDICATE0D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D/FalseUP0D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate0D/FalseUP0D.cpp
new file mode 100644
index 00000000000..53930660f3f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate0D/FalseUP0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_FalseUP0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FalseUP0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_FalseUP0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D/TrueUP0D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate0D/TrueUP0D.cpp
new file mode 100644
index 00000000000..776e49b5d77
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate0D/TrueUP0D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_TrueUP0D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TrueUP0D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TrueUP0D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp
new file mode 100644
index 00000000000..bbbc9bfcc43
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp
@@ -0,0 +1,170 @@
+#include "UnaryPredicate1D.h"
+
+#include "Convert.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*---------------  Python API function prototypes for UnaryPredicate1D instance  -----------*/
+static int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds);
+static void UnaryPredicate1D___dealloc__(BPy_UnaryPredicate1D *self);
+static PyObject * UnaryPredicate1D___repr__(BPy_UnaryPredicate1D *self);
+
+static PyObject * UnaryPredicate1D_getName( BPy_UnaryPredicate1D *self, PyObject *args);
+static PyObject * UnaryPredicate1D___call__( BPy_UnaryPredicate1D *self, PyObject *args);
+
+/*----------------------UnaryPredicate1D instance definitions ----------------------------*/
+static PyMethodDef BPy_UnaryPredicate1D_methods[] = {
+	{"getName", ( PyCFunction ) UnaryPredicate1D_getName, METH_NOARGS, ""},
+	{"__call__", ( PyCFunction ) UnaryPredicate1D___call__, METH_VARARGS, "" },
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_UnaryPredicate1D type definition ------------------------------*/
+
+PyTypeObject UnaryPredicate1D_Type = {
+	PyObject_HEAD_INIT( NULL ) 
+	0,							/* ob_size */
+	"UnaryPredicate1D",				/* tp_name */
+	sizeof( BPy_UnaryPredicate1D ),	/* tp_basicsize */
+	0,							/* tp_itemsize */
+	
+	/* methods */
+	(destructor)UnaryPredicate1D___dealloc__,	/* tp_dealloc */
+	NULL,                       				/* printfunc tp_print; */
+	NULL,                       				/* getattrfunc tp_getattr; */
+	NULL,                       				/* setattrfunc tp_setattr; */
+	NULL,										/* tp_compare */
+	(reprfunc)UnaryPredicate1D___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_UnaryPredicate1D_methods,	/* struct PyMethodDef *tp_methods; */
+	NULL,                       	/* struct PyMemberDef *tp_members; */
+	NULL,         					/* struct PyGetSetDef *tp_getset; */
+	NULL,							/* struct _typeobject *tp_base; */
+	NULL,							/* PyObject *tp_dict; */
+	NULL,							/* descrgetfunc tp_descr_get; */
+	NULL,							/* descrsetfunc tp_descr_set; */
+	0,                          	/* long tp_dictoffset; */
+	(initproc)UnaryPredicate1D___init__, /* initproc tp_init; */
+	NULL,							/* allocfunc tp_alloc; */
+	PyType_GenericNew,		/* 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 UnaryPredicate1D_Init( PyObject *module )
+{
+	if( module == NULL )
+		return;
+
+	if( PyType_Ready( &UnaryPredicate1D_Type ) < 0 )
+		return;
+	Py_INCREF( &UnaryPredicate1D_Type );
+	PyModule_AddObject(module, "UnaryPredicate1D", (PyObject *)&UnaryPredicate1D_Type);
+}
+
+//------------------------INSTANCE METHODS ----------------------------------
+
+int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds)
+{
+	return 0;
+}
+
+void UnaryPredicate1D___dealloc__(BPy_UnaryPredicate1D* self)
+{
+	delete self->up1D;
+    self->ob_type->tp_free((PyObject*)self);
+}
+
+
+PyObject * UnaryPredicate1D___repr__(BPy_UnaryPredicate1D* self)
+{
+    return PyString_FromFormat("type: %s - address: %p", self->up1D->getName().c_str(), self->up1D );
+}
+
+
+PyObject * UnaryPredicate1D_getName( BPy_UnaryPredicate1D *self, PyObject *args)
+{
+	return PyString_FromString( self->up1D->getName().c_str() );
+}
+
+PyObject * UnaryPredicate1D___call__( BPy_UnaryPredicate1D *self, PyObject *args)
+{
+	PyObject *l;
+
+	if( !PyArg_ParseTuple(args, "O", &l) ) {
+		cout << "ERROR: UnaryPredicate1D___call__ " << endl;		
+		return NULL;
+	}
+	
+	//TBD
+	
+	Py_RETURN_NONE;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D.h b/source/blender/freestyle/intern/python/UnaryPredicate1D.h
new file mode 100644
index 00000000000..509d81f6937
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D.h
@@ -0,0 +1,34 @@
+#ifndef FREESTYLE_PYTHON_UNARYPREDICATE1D_H
+#define FREESTYLE_PYTHON_UNARYPREDICATE1D_H
+
+#include "../stroke/Predicates1D.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#include <Python.h>
+
+extern PyTypeObject UnaryPredicate1D_Type;
+
+#define BPy_UnaryPredicate1D_Check(v)	(( (PyObject *) v)->ob_type == &UnaryPredicate1D_Type)
+
+/*---------------------------Python BPy_UnaryPredicate1D structure definition----------*/
+typedef struct {
+	PyObject_HEAD
+	UnaryPredicate1D *up1D;
+} BPy_UnaryPredicate1D;
+
+/*---------------------------Python BPy_UnaryPredicate1D visible prototypes-----------*/
+
+PyMODINIT_FUNC UnaryPredicate1D_Init( PyObject *module );
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FREESTYLE_PYTHON_UNARYPREDICATE1D_H */
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/ContourUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/ContourUP1D.cpp
new file mode 100644
index 00000000000..89ba9f3f683
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/ContourUP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ContourUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ContourUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ContourUP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ContourUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/DensityLowerThanUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/DensityLowerThanUP1D.cpp
new file mode 100644
index 00000000000..664d73d59c1
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/DensityLowerThanUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_DensityLowerThanUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_DensityLowerThanUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_DensityLowerThanUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToChainingTimeStampUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToChainingTimeStampUP1D.cpp
new file mode 100644
index 00000000000..7cd9c17a99b
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToChainingTimeStampUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_EqualToChainingTimeStampUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_EqualToChainingTimeStampUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_EqualToChainingTimeStampUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToTimeStampUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToTimeStampUP1D.cpp
new file mode 100644
index 00000000000..d6925dd2b44
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/EqualToTimeStampUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_EqualToTimeStampUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_EqualToTimeStampUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_EqualToTimeStampUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/ExternalContourUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/ExternalContourUP1D.cpp
new file mode 100644
index 00000000000..9107f0fe326
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/ExternalContourUP1D.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ExternalContourUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ExternalContourUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ExternalContourUP1D(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ExternalContourUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/FalseUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/FalseUP1D.cpp
new file mode 100644
index 00000000000..6164463a3af
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/FalseUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_FalseUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_FalseUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_FalseUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/QuantitativeInvisibilityUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/QuantitativeInvisibilityUP1D.cpp
new file mode 100644
index 00000000000..fc538008446
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/QuantitativeInvisibilityUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_QuantitativeInvisibilityUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_QuantitativeInvisibilityUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_QuantitativeInvisibilityUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/ShapeUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/ShapeUP1D.cpp
new file mode 100644
index 00000000000..4ec5cc13b3a
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/ShapeUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ShapeUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ShapeUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ShapeUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D/TrueUP1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D/TrueUP1D.cpp
new file mode 100644
index 00000000000..7c8e0a6239d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/UnaryPredicate1D/TrueUP1D.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_TrueUP1D_getName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_TrueUP1D___call__(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_TrueUP1D(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/ViewEdgeIterator.cpp b/source/blender/freestyle/intern/python/ViewEdgeIterator.cpp
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewEdgeIterator.cpp
diff --git a/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator.cpp b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator.cpp
new file mode 100644
index 00000000000..18ab37aeecd
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator.cpp
@@ -0,0 +1,36 @@
+ PyObject *_wrap_ChainingIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_init(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_traverse(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_getVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_isIncrementing(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_increment(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainingIterator_decrement(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ChainingIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_ChainingIterator(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainPredicateIterator.cpp b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainPredicateIterator.cpp
new file mode 100644
index 00000000000..3b3b4433e59
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainPredicateIterator.cpp
@@ -0,0 +1,12 @@
+ PyObject *_wrap_ChainPredicateIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainPredicateIterator_traverse(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_ChainPredicateIterator(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainSilhouetteIterator.cpp b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainSilhouetteIterator.cpp
new file mode 100644
index 00000000000..53d37c1578c
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewEdgeIterator/ChainingIterator/ChainSilhouetteIterator.cpp
@@ -0,0 +1,16 @@
+ PyObject *_wrap_ChainSilhouetteIterator_getExactTypeName(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ChainSilhouetteIterator_traverse(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ChainSilhouetteIterator(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_disown_ChainSilhouetteIterator(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/ViewMap.cpp b/source/blender/freestyle/intern/python/ViewMap.cpp
new file mode 100644
index 00000000000..24a986b3885
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewMap.cpp
@@ -0,0 +1,104 @@
+ PyObject *_wrap_ViewMap_userdata_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_userdata_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewMap(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ViewMap(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_GetClosestViewEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_GetClosestFEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_getInstance(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_ViewShapes(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_ViewEdges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_ViewVertices(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_FEdges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_SVertices(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_viewedges_begin(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_viewedges_end(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_viewedges_size(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_viewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_shapeIdToIndexMap(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_getScene3dBBox(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_AddViewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_AddViewEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_AddViewVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_AddFEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_AddSVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_setScene3dBBox(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_CreateTVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewMap_InsertViewVertex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/ViewShape.cpp b/source/blender/freestyle/intern/python/ViewShape.cpp
new file mode 100644
index 00000000000..023ce06f44f
--- /dev/null
+++ b/source/blender/freestyle/intern/python/ViewShape.cpp
@@ -0,0 +1,88 @@
+ PyObject *_wrap_ViewShape_userdata_set(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_userdata_get(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewShape__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewShape__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewShape__SWIG_2(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_new_ViewShape(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_dupplicate(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_delete_ViewShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_SplitEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_sshape__SWIG_0(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_sshape__SWIG_1(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_sshape(PyObject *self, PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_vertices(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_edges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_getId(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_SetSShape(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_SetVertices(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_SetEdges(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_AddVertex(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_AddEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_RemoveEdge(PyObject *self , PyObject *args) {
+}
+
+
+ PyObject *_wrap_ViewShape_RemoveVertex(PyObject *self , PyObject *args) {
+}
+
+
diff --git a/source/blender/freestyle/intern/python/orientedViewEdgeIterator.cpp b/source/blender/freestyle/intern/python/orientedViewEdgeIterator.cpp
new file mode 100644
index 00000000000..e69de29bb2d
--- /dev/null
+++ b/source/blender/freestyle/intern/python/orientedViewEdgeIterator.cpp
diff --git a/source/blender/freestyle/intern/rendering/GLBBoxRenderer.cpp b/source/blender/freestyle/intern/rendering/GLBBoxRenderer.cpp
new file mode 100755
index 00000000000..464779d6a43
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLBBoxRenderer.cpp
@@ -0,0 +1,108 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GLBBoxRenderer.h"
+#include "../scene_graph/IndexedFaceSet.h"
+#include "../scene_graph/NodeDrawingStyle.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/NodeLight.h"
+#include "../scene_graph/NodeTransform.h"
+
+#include "../scene_graph/Rep.h"
+#include "../scene_graph/Node.h"
+
+void GLBBoxRenderer::visitIndexedFaceSet(IndexedFaceSet& iFaceSet)  
+{
+  RenderRep(iFaceSet);
+}
+
+void GLBBoxRenderer::visitNodeGroup(NodeGroup& iGroupNode)  
+{
+  RenderNode(iGroupNode);
+}
+
+void GLBBoxRenderer::visitNodeTransform(NodeTransform& iTransformNode)
+{
+  RenderNode(iTransformNode);
+}
+
+void GLBBoxRenderer::visitDrawingStyle(DrawingStyle& iDrawingStyle) 
+{
+  if(DrawingStyle::INVISIBLE == iDrawingStyle.style())
+    return ;
+
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glEnable(GL_BLEND);
+  glEnable(GL_LINE_SMOOTH);
+  glPolygonMode(GL_FRONT, GL_LINE);
+  glLineWidth(1.f);
+
+  glDisable(GL_LIGHTING);
+}
+
+void GLBBoxRenderer::RenderRep(const Rep& iRep) const 
+{
+  RenderBBox(iRep.bbox());
+}
+
+void GLBBoxRenderer::RenderNode(const Node& iNode) const 
+{
+  RenderBBox(iNode.bbox());
+}
+
+void GLBBoxRenderer::RenderBBox(const BBox<Vec3r>& iBox) const 
+{
+  if(iBox.empty())
+    return;
+
+  Vec3r m = iBox.getMin();
+  Vec3r M = iBox.getMax();
+
+  glColor3f(0.f, 0.f, 0.f);
+  glBegin(GL_LINE_LOOP);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], m[1], m[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], m[1], m[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], M[1], m[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], M[1], m[2]);
+  glEnd();
+  
+  glBegin(GL_LINE_LOOP);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], m[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], m[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], M[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], M[1], M[2]);
+  glEnd();
+  
+  glBegin(GL_LINE_LOOP);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], m[1], m[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], m[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], M[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(m[0], M[1], m[2]);
+  glEnd();
+  
+  glBegin(GL_LINE_LOOP);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], m[1], m[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], m[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], M[1], M[2]);
+  ((GLBBoxRenderer*)(this))->glVertex3r(M[0], M[1], m[2]);
+  glEnd();
+
+}
diff --git a/source/blender/freestyle/intern/rendering/GLBBoxRenderer.h b/source/blender/freestyle/intern/rendering/GLBBoxRenderer.h
new file mode 100755
index 00000000000..4bb72ba80b0
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLBBoxRenderer.h
@@ -0,0 +1,59 @@
+//
+//  Filename         : GLBBoxRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to render BBoxes of a 3D scene thanks to OpenGL
+//  Date of creation : 07/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GLBBOXRENDERER_H
+# define GLBBOXRENDERER_H
+
+# include "../system/FreestyleConfig.h"
+# include "GLRenderer.h"
+# include "../geometry/BBox.h"
+
+class Rep;
+class Node;
+
+class LIB_RENDERING_EXPORT GLBBoxRenderer : public GLRenderer
+{
+public:
+
+  inline GLBBoxRenderer() : GLRenderer() {}
+  virtual ~GLBBoxRenderer() {}
+
+  VISIT_DECL(NodeGroup)
+  VISIT_DECL(NodeTransform)
+  VISIT_DECL(IndexedFaceSet)
+  VISIT_DECL(DrawingStyle)
+
+ protected:
+
+  void RenderRep(const Rep& iRep) const ;
+  void RenderNode(const Node& iNode) const ;
+  void RenderBBox(const BBox<Vec3r>& iBox) const ;
+};
+
+#endif // GLBBOXRENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLDebugRenderer.cpp b/source/blender/freestyle/intern/rendering/GLDebugRenderer.cpp
new file mode 100755
index 00000000000..716db397e94
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLDebugRenderer.cpp
@@ -0,0 +1,197 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include "../scene_graph/VertexRep.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/IndexedFaceSet.h"
+#include "../scene_graph/LineRep.h"
+#include "../geometry/Grid.h"
+
+#include "GLDebugRenderer.h"
+
+#ifdef __MACH__
+#include <GLUT/glut.h>
+#else
+#include <GL/glut.h>
+#endif
+
+void GLDebugRenderer::visitIndexedFaceSet(IndexedFaceSet& iFaceSet)  
+{
+  unsigned int fIndex = 0;
+  
+  const real * vertices = iFaceSet.vertices();
+  const real * normals = iFaceSet.normals();
+  const Material *const* materials = (const Material**)iFaceSet.materials();
+  const unsigned *vindices = iFaceSet.vindices();
+  const unsigned *nindices = iFaceSet.nindices();
+  const unsigned *mindices = iFaceSet.mindices();
+  const unsigned numfaces = iFaceSet.numFaces();
+  const unsigned *numVertexPerFace = iFaceSet.numVertexPerFaces();
+  const IndexedFaceSet::TRIANGLES_STYLE * faceStyle = iFaceSet.trianglesStyle();  
+
+  const unsigned *pvi = vindices;
+  const unsigned *pni = nindices;
+  const unsigned* pmi = mindices;
+
+  for(fIndex=0; fIndex<numfaces; fIndex++)
+  {
+    switch(faceStyle[fIndex])
+    {
+    case IndexedFaceSet::TRIANGLE_STRIP:
+      RenderTriangleStrip(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLE_FAN:
+      RenderTriangleFan(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLES:
+      RenderTriangles(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      break;
+    }
+    pvi += numVertexPerFace[fIndex];
+    pni += numVertexPerFace[fIndex];
+    pmi += numVertexPerFace[fIndex];
+  }
+}
+
+void GLDebugRenderer::visitNodeShape(NodeShape& iShapeNode) 
+{
+  // Gets the bbox size:
+  real minY = iShapeNode.bbox().getMin()[1];
+  real maxY = iShapeNode.bbox().getMax()[1];
+  
+  // sets the text size:
+  _bboxSize = fabs((maxY-minY)); ///1000.f;
+}
+
+void GLDebugRenderer::visitLineRep(LineRep& iLine) 
+{ 
+
+  glColor3f(0,0,0);
+
+  GLRenderer::visitLineRep(iLine);
+}
+
+void GLDebugRenderer::visitOrientedLineRep(OrientedLineRep& iLine) 
+{
+  GLRenderer::visitOrientedLineRep(iLine);
+}
+
+void GLDebugRenderer::visitVertexRep(VertexRep& iVertex) 
+{
+  glPointSize(3.0);
+
+  GLRenderer::visitVertexRep(iVertex);
+}
+
+
+void GLDebugRenderer::renderBitmapString(real x, 
+					 real y, 
+					 real z, 
+					 void *font, 
+					 char *string,
+					 float size) 
+{  
+  char *c;
+  
+  glPushMatrix();
+  glTranslater(x, y,z);
+  real textSize = min(_bboxSize/10.0, _minEdgeSize/2.0);
+  // adjust the text size so as it 
+  // is acceptable giving the bbox size:
+  while(_bboxSize/textSize>1000)
+    textSize *= 10.0;
+
+  glScalef(size, size, size);
+  glScalef(textSize/200.0, textSize/200.0, textSize/200.0);
+  for (c=string; *c != '\0'; c++) 
+  {
+    //soc glutStrokeCharacter(font, *c);
+  }
+  glPopMatrix();
+}
+
+void GLDebugRenderer::RenderTriangleStrip(const real *iVertices, 
+                                          const real *iNormals,
+                                          const Material *const* iMaterials, 
+                                          const unsigned* iVIndices, 
+                                          const unsigned* iNIndices,
+                                          const unsigned* iMIndices,
+                                          const unsigned iNVertices) 
+{
+  //  glBegin(GL_TRIANGLE_STRIP);
+  //  for(unsigned int i=0; i<iNVertices; i++)
+  //  {
+  //    glNormal3r(iNormals[iNIndices[i]], 
+  //               iNormals[iNIndices[i]+1],
+  //               iNormals[iNIndices[i]+2]);
+  //
+  //    glVertex3r( iVertices[iVIndices[i]], 
+  //                iVertices[iVIndices[i]+1],
+  //                iVertices[iVIndices[i]+2]);
+  //  }
+  //  glEnd();
+}
+
+void GLDebugRenderer::RenderTriangleFan(const real *iVertices, 
+                                        const real *iNormals,
+                                        const Material *const* iMaterials, 
+                                        const unsigned* iVIndices, 
+                                        const unsigned* iNIndices,
+                                        const unsigned* iMIndices,
+                                        const unsigned iNVertices)  
+{
+  //  glBegin(GL_TRIANGLE_FAN);
+  //  for(unsigned int i=0; i<iNVertices; i++)
+  //  {
+  //    glNormal3r(iNormals[iNIndices[i]], 
+  //               iNormals[iNIndices[i]+1],
+  //               iNormals[iNIndices[i]+2]);
+  //
+  //    glVertex3r( iVertices[iVIndices[i]], 
+  //                iVertices[iVIndices[i]+1],
+  //                iVertices[iVIndices[i]+2]);
+  //  }
+  //  glEnd();
+}
+
+void GLDebugRenderer::RenderTriangles(const real *iVertices, 
+                                      const real *iNormals,
+                                      const Material *const* iMaterials, 
+                                      const unsigned* iVIndices, 
+                                      const unsigned* iNIndices,
+                                      const unsigned* iMIndices,
+                                      const unsigned iNVertices)  
+{
+  //  // Renders the normals:
+  //  glBegin(GL_LINES);
+  //  for(unsigned int i=0; i<iNVertices; i++)
+  //  { 
+  //    glVertex3r( iVertices[iVIndices[i]], 
+  //      iVertices[iVIndices[i]+1],
+  //      iVertices[iVIndices[i]+2]);
+  //    
+  //    glVertex3r(iVertices[iVIndices[i]] + iNormals[iNIndices[i]]/10.f, 
+  //      iVertices[iVIndices[i]+1] + iNormals[iNIndices[i]+1]/10.f,
+  //      iVertices[iVIndices[i]+2] + iNormals[iNIndices[i]+2]/10.f);
+  //  }
+  //  glEnd();
+}
diff --git a/source/blender/freestyle/intern/rendering/GLDebugRenderer.h b/source/blender/freestyle/intern/rendering/GLDebugRenderer.h
new file mode 100755
index 00000000000..e0f97249645
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLDebugRenderer.h
@@ -0,0 +1,182 @@
+//
+//  Filename         : GLDebugRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to render the debug informations related to
+//                     a scene
+//  Date of creation : 03/04/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GLDEBUGRENDERER_H
+# define GLDEBUGRENDERER_H
+
+# include <float.h>
+# include "../system/FreestyleConfig.h"
+# include "GLRenderer.h"
+# include "../view_map/Silhouette.h"
+# include "../winged_edge/Curvature.h"
+
+class WSMeshShape;
+class WSExactShape;
+
+class LIB_RENDERING_EXPORT GLDebugRenderer : public GLRenderer
+{
+public:
+
+  inline GLDebugRenderer() : GLRenderer() {
+    _bboxSize = 2.0;
+    setMaxValue(&_minEdgeSize);
+    _SelectedFEdge = 0;
+  }
+
+  inline ~GLDebugRenderer() {}
+
+  VISIT_DECL(NodeShape)
+
+  VISIT_DECL(IndexedFaceSet)
+  VISIT_DECL(LineRep)
+  VISIT_DECL(OrientedLineRep)
+  VISIT_DECL(VertexRep)
+
+  /*! Renders a bitmap string in world coordinates 
+   *  x, y, z
+   *    The world coordinates of the sentence's starting point
+   *  font
+   *    The font used to display the text. 
+   *    Must be one of :
+   *    - GLUT_STROKE_ROMAN 
+   *    - GLUT_STROKE_MONO_ROMAN 
+   *  string
+   *    The text to display
+   *  size
+   *    The relative size of the text to display
+   */
+  void renderBitmapString(real x, 
+			  real y, 
+			  real z, 
+			  void *font, 
+			  char *string,
+			  float size = 1.f)  ; 
+
+  /*! Reinitialize the Renderer so as the previous 
+   *  text size does not affect the current one.
+   *  iBBoxSize
+   *    The size of the scene bounding box.
+   */
+  inline void ReInit(real iBBoxSize) {_bboxSize = iBBoxSize; setMaxValue(&_minEdgeSize);}
+
+  inline void setSelectedFEdge(FEdge *iFEdge) {_SelectedFEdge = iFEdge;}
+  inline FEdge * selectedFEdge() {return _SelectedFEdge;}
+
+protected:
+
+  /*! Renders a face made of a triangles strip
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangleStrip(const real *iVertices, 
+                                   const real *iNormals,
+                                   const Material *const* iMaterials, 
+                                   const unsigned* iVIndices, 
+                                   const unsigned* iNIndices,
+                                   const unsigned* iMIndices,
+                                   const unsigned iNVertices);
+
+  /*! Renders a face made of a triangles fan
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangleFan(const real *iVertices, 
+                                   const real *iNormals,
+                                   const Material *const*iMaterials, 
+                                   const unsigned* iVIndices, 
+                                   const unsigned* iNIndices,
+                                   const unsigned* iMIndices,
+                                   const unsigned iNVertices);
+
+  /*! Renders a face made of single triangles
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangles(const real *iVertices, 
+                                   const real *iNormals,
+                                   const Material *const* iMaterials, 
+                                   const unsigned* iVIndices, 
+                                   const unsigned* iNIndices,
+                                   const unsigned* iMIndices,
+                                   const unsigned iNVertices);
+
+  /*! glTranslatef or glTranslated */
+  inline void glTranslater(float x, float y, float z) {glTranslatef(x,y,z);}
+  inline void glTranslater(real x, real y, real z) {glTranslated(x,y,z);}
+
+
+private:
+
+  inline void setMaxValue(float *oValue) {*oValue = FLT_MAX;}
+  inline void setMaxValue(real *oValue) {*oValue = DBL_MAX;}
+
+  mutable real _bboxSize; 
+  mutable real _minEdgeSize;
+
+  FEdge *_SelectedFEdge;
+};
+
+#endif // GLDEBUGRENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.cpp b/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.cpp
new file mode 100644
index 00000000000..b5a835f5104
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.cpp
@@ -0,0 +1,27 @@
+#include "GLFreeMemoryVisitor.h"
+#include "../scene_graph/IndexedFaceSet.h"
+
+# ifdef WIN32
+#  include <windows.h>
+# endif
+# ifdef __MACH__
+#  include <OpenGL/gl.h>
+# else
+#  include <GL/gl.h>
+# endif
+
+GLFreeMemoryVisitor::GLFreeMemoryVisitor()
+:SceneVisitor(){
+}
+
+GLFreeMemoryVisitor::~GLFreeMemoryVisitor(){
+}
+
+void GLFreeMemoryVisitor::visitIndexedFaceSet(IndexedFaceSet& ifs){
+    GLuint dl = ifs.displayList();
+    if(dl != 0){
+        if(glIsList(dl)){
+            glDeleteLists(dl, 1);
+        }
+    }
+}
diff --git a/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.h b/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.h
new file mode 100644
index 00000000000..dd6412b1bb7
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLFreeMemoryVisitor.h
@@ -0,0 +1,23 @@
+#ifndef GL_FREE_MEMORY_VISITOR_H_
+#define GL_FREE_MEMORY_VISITOR_H_
+
+# include "../system/FreestyleConfig.h"
+# include "../scene_graph/SceneVisitor.h"
+
+/*! Mainly used to delete display lists */
+class LIB_RENDERING_EXPORT GLFreeMemoryVisitor : public SceneVisitor
+{
+public:
+
+    GLFreeMemoryVisitor() ;
+    virtual ~GLFreeMemoryVisitor() ;
+
+    //
+    // visitClass methods
+    //
+    //////////////////////////////////////////////
+
+        VISIT_DECL(IndexedFaceSet)
+};
+
+#endif // GL_FREE_MEMORY_H_
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.cpp b/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.cpp
new file mode 100755
index 00000000000..792846fa020
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.cpp
@@ -0,0 +1,43 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GLMonoColorRenderer.h"
+
+void GLMonoColorRenderer::visitMaterial(Material&) {
+  glColor3f(_r, _g, _b);
+}
+
+void GLMonoColorRenderer::visitDrawingStyle(DrawingStyle&) {
+  glDisable(GL_LIGHTING);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glEnable(GL_BLEND);
+  glEnable(GL_LINE_SMOOTH);
+  glLineWidth(3.0);
+  glPolygonMode(GL_BACK, GL_LINE);
+  //glPolygonMode(GL_BACK, GL_FILL);
+}
+
+void GLMonoColorRenderer::setColor(float r, float g, float b, float alpha) {
+  _r = r;
+  _g = g;
+  _b = b;
+  _alpha = alpha;
+}
diff --git a/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.h b/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.h
new file mode 100755
index 00000000000..d8e3cf536ec
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLMonoColorRenderer.h
@@ -0,0 +1,60 @@
+//
+//  Filename         : GLMonoColorRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to render 3D scene in 2 colors thanks to OpenGL
+//  Date of creation : 07/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GLMONOCOLORRENDERER_H
+# define GLMONOCOLORRENDERER_H
+
+# include "../system/FreestyleConfig.h"
+# include "GLRenderer.h"
+
+class LIB_RENDERING_EXPORT GLMonoColorRenderer : public GLRenderer
+{
+ public:
+
+  GLMonoColorRenderer() : GLRenderer() {
+    _r = _g = _b = 0.f;
+    _alpha = 1.f;
+  }
+
+  virtual ~GLMonoColorRenderer() {}
+
+  VISIT_DECL(DrawingStyle)
+  VISIT_DECL(Material)
+
+  void setColor(float r, float g, float b, float alpha = 1.f);
+
+private:
+
+  float _r;
+  float _g;
+  float _b;
+  float _alpha;
+};
+
+#endif // GLMONOCOLORRENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLRenderer.cpp b/source/blender/freestyle/intern/rendering/GLRenderer.cpp
new file mode 100755
index 00000000000..45693413ace
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLRenderer.cpp
@@ -0,0 +1,467 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../scene_graph/IndexedFaceSet.h"
+#include "../scene_graph/NodeDrawingStyle.h"
+#include "../scene_graph/NodeLight.h"
+#include "../scene_graph/NodeCamera.h"
+#include "../scene_graph/NodeTransform.h"
+#include "../scene_graph/NodeShape.h"
+#include "../scene_graph/OrientedLineRep.h"
+#include "../scene_graph/VertexRep.h"
+#include "../stroke/Stroke.h"
+
+#include "../scene_graph/TriangleRep.h"
+
+#include "GLRenderer.h"
+
+static GLenum lights[8] = {GL_LIGHT0, 
+                    GL_LIGHT1, 
+                    GL_LIGHT2, 
+                    GL_LIGHT3, 
+                    GL_LIGHT4,
+                    GL_LIGHT5,
+                    GL_LIGHT6,
+                    GL_LIGHT7};
+
+void GLRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
+{
+  /*GLuint dl = ifs.displayList();
+  if(dl != 0){
+    glCallList(dl);
+    return;
+  }*/
+  unsigned int fIndex = 0;
+  
+  const real * vertices = ifs.vertices();
+  const real * normals = ifs.normals();
+  const real * texCoords = ifs.texCoords();
+  const Material *const* materials = ifs.materials();
+  const unsigned *vindices = ifs.vindices();
+  const unsigned *nindices = ifs.nindices();
+  const unsigned *mindices = ifs.mindices();
+  const unsigned *tindices = ifs.tindices();
+  const unsigned numfaces = ifs.numFaces();
+  const IndexedFaceSet::TRIANGLES_STYLE * faceStyle = ifs.trianglesStyle();
+  const unsigned *numVertexPerFace = ifs.numVertexPerFaces();
+  
+
+  const unsigned* pvi = vindices;
+  const unsigned* pni = nindices;
+  const unsigned* pmi = mindices;
+  const unsigned* pti = tindices;
+
+  //dl = glGenLists(1);
+  //glNewList(dl, GL_COMPILE_AND_EXECUTE);
+  for(fIndex=0; fIndex<numfaces; fIndex++)
+  {
+    switch(faceStyle[fIndex])
+    {
+    case IndexedFaceSet::TRIANGLE_STRIP:
+      RenderTriangleStrip(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLE_FAN:
+      RenderTriangleFan(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLES:
+      RenderTriangles(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    }
+    pvi += numVertexPerFace[fIndex];
+    pni += numVertexPerFace[fIndex];
+		if(pmi)
+			pmi += numVertexPerFace[fIndex];
+    if(pti)
+        pti += numVertexPerFace[fIndex];
+  }
+  //glEndList();
+  //ifs.setDisplayList(dl);
+}
+
+void GLRenderer::visitNodeTransform(NodeTransform& tn) {
+  if(tn.scaled())
+    glEnable(GL_NORMALIZE);
+}
+
+void GLRenderer::visitNodeTransformBefore(NodeTransform& tn) {
+  glPushMatrix();
+
+  // Now apply transform
+  applyTransform(tn.matrix());
+}
+
+void GLRenderer::visitNodeTransformAfter(NodeTransform& tn) {
+  glPopMatrix();
+}
+
+void GLRenderer::visitNodeLight(NodeLight& ln)  
+{
+  if(true != ln.isOn())
+    return;
+
+  int number = ln.number();
+  
+  glLightfv(lights[number], GL_AMBIENT, ln.ambient());
+  glLightfv(lights[number], GL_DIFFUSE, ln.diffuse());
+  glLightfv(lights[number], GL_SPECULAR, ln.specular());
+  glLightfv(lights[number], GL_POSITION, ln.position());
+
+  glEnable(lights[number]);
+}
+
+void GLRenderer::visitNodeCamera(NodeCamera& cn)  
+{
+    const double * mvm = cn.modelViewMatrix();
+    const double * pm = cn.projectionMatrix();
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMultMatrixd(pm);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glMultMatrixd(mvm);
+
+
+}
+
+void GLRenderer::visitNodeDrawingStyleBefore(NodeDrawingStyle& ds) {
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+}
+
+void GLRenderer::visitNodeDrawingStyleAfter(NodeDrawingStyle&) {
+  glPopAttrib();
+}
+
+void GLRenderer::RenderTriangleStrip( const real *iVertices, 
+                                     const real *iNormals,
+                                     const Material *const* iMaterials,
+                                     const real *iTexCoords,
+                                     const unsigned* iVIndices, 
+                                     const unsigned* iNIndices,
+                                     const unsigned* iMIndices,
+                                     const unsigned* iTIndices,
+                                     const unsigned iNVertices) 
+{
+  unsigned index = -1;
+  glBegin(GL_TRIANGLE_STRIP);
+  for(unsigned int i=0; i<iNVertices; i++)
+  {
+		if(iMIndices){
+			if(iMIndices[i] != index){
+				visitMaterial(*(iMaterials[iMIndices[i]]));
+				index = iMIndices[i];
+			}
+		}
+
+        if(iTIndices){
+            glTexCoord2f(   iTexCoords[iTIndices[i]],
+                            iTexCoords[iTIndices[i]+1]);
+		}
+    
+    glNormal3r(iNormals[iNIndices[i]], 
+               iNormals[iNIndices[i]+1],
+               iNormals[iNIndices[i]+2]);
+
+    glVertex3r( iVertices[iVIndices[i]], 
+                iVertices[iVIndices[i]+1],
+                iVertices[iVIndices[i]+2]);
+  }
+  glEnd();
+}
+
+void GLRenderer::RenderTriangleFan( const real *iVertices, 
+                                    const real *iNormals,
+                                    const Material *const* iMaterials,
+                                    const real *iTexCoords,
+                                    const unsigned* iVIndices, 
+                                    const unsigned* iNIndices,
+                                    const unsigned* iMIndices,
+                                    const unsigned* iTIndices,
+                                    const unsigned iNVertices)  
+{
+  unsigned index = -1;
+  glBegin(GL_TRIANGLE_FAN);
+  for(unsigned int i=0; i<iNVertices; i++)
+  {
+		if(iMIndices){
+			if(iMIndices[i] != index){
+				visitMaterial(*(iMaterials[iMIndices[i]]));
+				index = iMIndices[i];
+			}
+		}
+        if(iTIndices){
+            glTexCoord2f(   iTexCoords[iTIndices[i]],
+                            iTexCoords[iTIndices[i]+1]);
+		}
+
+    glNormal3r(iNormals[iNIndices[i]], 
+               iNormals[iNIndices[i]+1],
+               iNormals[iNIndices[i]+2]);
+
+    glVertex3r( iVertices[iVIndices[i]], 
+                iVertices[iVIndices[i]+1],
+                iVertices[iVIndices[i]+2]);
+  }
+  glEnd();
+}
+
+void GLRenderer::RenderTriangles( const real *iVertices, 
+                                 const real *iNormals,
+                                 const Material *const* iMaterials,
+                                 const real *iTexCoords,
+                                 const unsigned* iVIndices, 
+                                 const unsigned* iNIndices,
+                                 const unsigned* iMIndices,
+                                 const unsigned* iTIndices,
+                                 const unsigned iNVertices)  
+{
+  unsigned index = -1;
+  glBegin(GL_TRIANGLES);
+  for(unsigned int i=0; i<iNVertices; i++)
+  {
+		if(iMIndices){
+			if(iMIndices[i] != index){
+				visitMaterial(*(iMaterials[iMIndices[i]]));
+				index = iMIndices[i];
+			}
+		}
+        if(iTIndices){
+            glTexCoord2f(   iTexCoords[iTIndices[i]],
+                            iTexCoords[iTIndices[i]+1]);
+		}
+
+    glNormal3r(iNormals[iNIndices[i]], 
+               iNormals[iNIndices[i]+1],
+               iNormals[iNIndices[i]+2]);
+
+    glVertex3r( iVertices[iVIndices[i]], 
+                iVertices[iVIndices[i]+1],
+                iVertices[iVIndices[i]+2]);
+  }
+  glEnd();
+}
+
+void GLRenderer::visitLineRep( LineRep& iLine) 
+{
+  if(iLine.width() != 0)
+    glLineWidth(iLine.width());
+
+  switch(iLine.style())
+  {
+  case LineRep::LINES:
+    glBegin(GL_LINES);
+    break;
+  case LineRep::LINE_STRIP:
+    glBegin(GL_LINE_STRIP);
+    break;
+  case LineRep::LINE_LOOP:
+    glBegin(GL_LINE_LOOP);
+    break;
+  default:
+    return;
+  }
+
+ const vector<Vec3r>& vertices = iLine.vertices();
+  //soc unused float step=1.f/vertices.size();
+  vector<Vec3r>::const_iterator v;
+
+  for(v=vertices.begin(); v!=vertices.end(); v++)
+    glVertex3r((*v)[0], (*v)[1], (*v)[2]);
+
+  glEnd();
+}
+
+
+void GLRenderer::visitTriangleRep( TriangleRep& iTriangle) 
+{
+  glPushAttrib(GL_ALL_ATTRIB_BITS);
+  switch(iTriangle.style())
+  {
+  case TriangleRep::FILL:
+    glPolygonMode(GL_FRONT, GL_FILL);
+    break;
+  case TriangleRep::LINES:
+    glPolygonMode(GL_FRONT, GL_LINES);
+    break;
+  default:
+    return;
+  }
+
+  glBegin(GL_TRIANGLES);
+  for(int i=0; i<3; ++i)
+  {
+    glColor3f(iTriangle.color(i)[0], iTriangle.color(i)[1], iTriangle.color(i)[2]);
+    glVertex3r(iTriangle.vertex(i)[0], iTriangle.vertex(i)[1], iTriangle.vertex(i)[2]);
+  }
+
+  glEnd();
+
+
+
+  glPopAttrib();
+
+}
+
+void GLRenderer::visitOrientedLineRep(OrientedLineRep& iLine) 
+{
+  switch(iLine.style())
+  {
+  case LineRep::LINES:
+    glBegin(GL_LINES);
+    break;
+  case LineRep::LINE_STRIP:
+    glBegin(GL_LINE_STRIP);
+    break;
+  case LineRep::LINE_LOOP:
+    glBegin(GL_LINE_LOOP);
+    break;
+  default:
+    return;
+  }
+
+  int i=0;
+  int ncolor = iLine.getId().getFirst()%3;
+  
+  const vector<Vec3r>& vertices = iLine.vertices();
+  float step=1.f/vertices.size();
+  vector<Vec3r>::const_iterator v;
+  for(v=vertices.begin(); v!=vertices.end(); v++)
+  {
+    switch(ncolor)
+    {
+    case 0:
+      glColor3f(i*step,0.f,0.f);
+      break;
+    case 1:
+      glColor3f(0.f, i*step, 0.f);
+      break;
+    case 2:
+      glColor3f(0.f, 0.f, i*step);
+      break;
+    default:
+      glColor3f(i*step, i*step,i*step);
+      break;
+    }
+    i++;
+    glVertex3r((*v)[0], (*v)[1], (*v)[2]);
+  }
+
+  glEnd();
+}
+
+void GLRenderer::visitVertexRep( VertexRep& iVertex) 
+{
+  if(iVertex.pointSize() != 0.f)
+    glPointSize(iVertex.pointSize());
+  
+  glBegin(GL_POINTS);
+  glVertex3r(iVertex.x(), iVertex.y(), iVertex.z());
+  glEnd();
+}
+
+void GLRenderer::visitDrawingStyle(DrawingStyle& iDrawingStyle) 
+{
+  
+  // Drawing Style management
+  switch(iDrawingStyle.style())
+  {
+  case DrawingStyle::FILLED:
+    glPolygonMode(GL_FRONT, GL_FILL);
+    glShadeModel(GL_SMOOTH);
+    break;
+
+  case DrawingStyle::LINES:
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_BLEND);
+    glEnable(GL_LINE_SMOOTH);
+    glPolygonMode(GL_FRONT, GL_LINE);
+    glLineWidth(iDrawingStyle.lineWidth());
+    break;
+
+  case DrawingStyle::POINTS:
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_BLEND);
+    glEnable(GL_POINT_SMOOTH);
+    glPolygonMode(GL_FRONT, GL_POINT);
+    glPointSize(iDrawingStyle.pointSize());
+    break;
+
+  case DrawingStyle::INVISIBLE:
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    glDepthMask(0);
+    break;
+
+  default:
+    break;
+  }
+
+  glLineWidth(iDrawingStyle.lineWidth());
+  glPointSize(iDrawingStyle.pointSize());
+
+  // FIXME
+  if(true == iDrawingStyle.lightingEnabled())
+    glEnable(GL_LIGHTING);
+  else
+    glDisable(GL_LIGHTING);
+}
+
+void GLRenderer::visitMaterial(Material& m) {
+  const float* diff = m.diffuse();
+  const float* amb = m.ambient();
+  const float* spec = m.specular();
+  const float* em = m.emission();
+
+  RenderColor(diff);
+  glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
+  glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
+  glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
+  glMaterialfv(GL_FRONT, GL_EMISSION, em);
+  glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
+}
+
+void GLRenderer::visitMaterial(const Material& m) {
+  const float* diff = m.diffuse();
+  const float* amb = m.ambient();
+  const float* spec = m.specular();
+  const float* em = m.emission();
+
+  RenderColor(diff);
+  glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
+  glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
+  glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
+  glMaterialfv(GL_FRONT, GL_EMISSION, em);
+  glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
+}
+void GLRenderer::applyTransform( const Matrix44r &iMatrix)  
+{
+  real m[16];
+  for(int lign=0; lign<4; lign++)
+    for(int column=0; column<4; column++)
+      m[column*4+lign] = iMatrix(lign, column);
+
+  glMultMatrixr(m);
+}
+
+void GLRenderer::RenderColor( const float *rgba)  
+{
+  glColor4fv(rgba);
+} 
diff --git a/source/blender/freestyle/intern/rendering/GLRenderer.h b/source/blender/freestyle/intern/rendering/GLRenderer.h
new file mode 100755
index 00000000000..ddbf082038b
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLRenderer.h
@@ -0,0 +1,204 @@
+//
+//  Filename         : GLRenderer.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class to render a 3D scene thanks to OpenGL
+//  Date of creation : 07/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GLRENDERER_H
+# define GLRENDERER_H
+
+# ifdef WIN32
+#  include <windows.h>
+# endif
+# ifdef __MACH__
+#  include <OpenGL/gl.h>
+# else
+#  include <GL/gl.h>
+# endif
+
+# include "../system/FreestyleConfig.h"
+# include "../system/Precision.h"
+# include "../scene_graph/SceneVisitor.h"
+# include "../geometry/Geom.h"
+using namespace Geometry; 
+
+class LIB_RENDERING_EXPORT GLRenderer : public SceneVisitor
+{
+ public:
+
+  inline GLRenderer() : SceneVisitor() {}
+  virtual ~GLRenderer() {}
+
+  //
+  // visitClass methods
+  //
+  //////////////////////////////////////////////
+
+  VISIT_DECL(NodeLight)
+  VISIT_DECL(NodeCamera)
+  VISIT_DECL(NodeTransform)
+
+  VISIT_DECL(LineRep)
+  VISIT_DECL(OrientedLineRep)
+  VISIT_DECL(TriangleRep)
+  VISIT_DECL(VertexRep)
+  VISIT_DECL(IndexedFaceSet)
+  VISIT_DECL(DrawingStyle)
+  VISIT_DECL(Material)
+
+  virtual void visitMaterial(const Material&);
+  virtual void visitNodeTransformBefore(NodeTransform&);
+  virtual void visitNodeTransformAfter(NodeTransform&);
+  virtual void visitNodeDrawingStyleBefore(NodeDrawingStyle&);
+  virtual void visitNodeDrawingStyleAfter(NodeDrawingStyle&);
+
+ protected:
+
+  /*! Renders a face made of a triangles strip
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iTexCoords
+   *      Array of float containing the face uv coords. 2 floats per 
+   *      u,v vertex texture coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iTIndices
+   *      Array of texture coordinates indices (to use with iTexCoords array)
+   *      describing the texture coordinates parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangleStrip(const real *iVertices, 
+                                   const real *iNormals,
+                                   const Material *const*iMaterials, 
+                                   const real *iTexCoords,
+                                   const unsigned* iVIndices, 
+                                   const unsigned* iNIndices,
+                                   const unsigned* iMIndices,
+                                   const unsigned* iTIndices,
+                                   const unsigned iNVertices) ;
+
+  /*! Renders a face made of a triangles fan
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iTexCoords
+   *      Array of float containing the face uv coords. 2 floats per 
+   *      u,v vertex texture coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iTIndices
+   *      Array of texture coordinates indices (to use with iTexCoords array)
+   *      describing the texture coordinates parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangleFan(const real *iVertices, 
+                                 const real *iNormals,
+                                 const Material *const* iMaterials,
+                                 const real *iTexCoords,
+                                 const unsigned* iVIndices, 
+                                 const unsigned* iNIndices,
+                                 const unsigned* iMIndices,
+                                 const unsigned* iTIndices,
+                                 const unsigned iNVertices) ;
+
+  /*! Renders a face made of single triangles
+   *    iVertices
+   *      Array of float containing the face vertices. 3 floats per 
+   *      x, y, z vertex coordinates
+   *    iNormals 
+   *      Array of float containing the face normals. 3 floats per 
+   *      x, y, z vertex normal coordinates
+   *    iTexCoords
+   *      Array of float containing the face uv coords. 2 floats per 
+   *      u,v vertex texture coordinates
+   *    iVIndices
+   *      Array of the indices (to use with the iVertices array) 
+   *      describing the vertices parsing order
+   *    iNIndices
+   *      Array of normals indices (to use with iNormals array)
+   *      describing the normals parsing order
+   *    iTIndices
+   *      Array of texture coordinates indices (to use with iTexCoords array)
+   *      describing the texture coordinates parsing order
+   *    iNVertices
+   *      The number of vertices in the face
+   */
+  virtual void RenderTriangles(const real *iVertices, 
+                               const real *iNormals,
+                               const Material *const* iMaterials, 
+                               const real *iTexCoords,
+                               const unsigned* iVIndices, 
+                               const unsigned* iNIndices,
+                               const unsigned* iMIndices,
+                               const unsigned* iTIndices,
+                               const unsigned iNVertices)  ;
+
+  /*! Apply a transform matrix by multiplying 
+   *  the current OpenGL ModelView Matrix by 
+   *  iMatrix
+   */
+  virtual void applyTransform( const Matrix44r &iMatrix)  ;
+
+  /*! Sets the current drawing color.
+   *  Active only when light is disabled
+   *  (simple call to glColor4fv)
+   *    rgba
+   *      array of 4 floats (r, g, b and alpha)
+   */
+  virtual void RenderColor( const float *rgba);
+
+  /*! glVertex3f or glVertex3d */
+  inline void glVertex3r(float x, float y, float z) {glVertex3f(x,y,z);}
+  inline void glVertex3r(real x, real y, real z) {glVertex3d(x,y,z);}
+
+  /*! glVertex3f or glNormal3d */
+  inline void glNormal3r(float x, float y, float z) {glNormal3f(x,y,z);}
+  inline void glNormal3r(real x, real y, real z) {glNormal3d(x,y,z);}
+
+  /*! glMultMatrixf or glMultMatrixd */
+  inline void glMultMatrixr(float *m) {glMultMatrixf(m);}
+  inline void glMultMatrixr(real *m) {glMultMatrixd(m);}
+
+};
+
+#endif // GLRENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLSelectRenderer.cpp b/source/blender/freestyle/intern/rendering/GLSelectRenderer.cpp
new file mode 100755
index 00000000000..b4a2406c644
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLSelectRenderer.cpp
@@ -0,0 +1,159 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../scene_graph/IndexedFaceSet.h"
+#include "../scene_graph/NodeShape.h"
+#include "GLSelectRenderer.h"
+
+static const float	INACTIVE_COLOR_MIN = 0.2;
+static const float	INACTIVE_COLOR_MAX = 0.8;
+static const float	INACTIVE_COLOR_OFFSET = 0.2;
+
+static const float	ACTIVE_COLOR[4] = {0.8,
+					   0.2,
+					   0.2,
+					   1};
+
+static float		selection_color[4] = {INACTIVE_COLOR_MIN,
+					      INACTIVE_COLOR_MIN,
+					      INACTIVE_COLOR_MIN,
+					      1};
+
+
+void GLSelectRenderer::resetColor() {
+  for (unsigned i = 0; i < 3; ++i)
+    selection_color[i] = INACTIVE_COLOR_MIN;
+}
+
+void GLSelectRenderer::visitNodeShape(NodeShape& sn) {
+  if (_gl_select_rendering)
+    return;
+  for (unsigned i = 0; i < 3; ++i) {
+    selection_color[i] += INACTIVE_COLOR_OFFSET;
+    if (selection_color[i] > INACTIVE_COLOR_MAX)
+      selection_color[i] = INACTIVE_COLOR_MIN;
+  }
+  if (sn.shapes()[0]->getId() == _selected_shape) {
+    _current_shape_active = true;
+    return;
+  }
+  _current_shape_active = false;
+}
+
+void GLSelectRenderer::visitMaterial(Material& m) {
+  if (_gl_select_rendering)
+    return;
+
+  const float* amb = m.ambient();
+  const float* spec = m.specular();
+  const float* em = m.emission();
+
+  if (_current_shape_active) {
+    RenderColor(ACTIVE_COLOR);
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, ACTIVE_COLOR);
+  } else {
+    RenderColor(selection_color);
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, selection_color);
+  }
+  glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
+  glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
+  glMaterialfv(GL_FRONT, GL_EMISSION, em);
+  glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
+}
+
+void GLSelectRenderer::visitMaterial(const Material& m) {
+  if (_gl_select_rendering)
+    return;
+
+  const float* amb = m.ambient();
+  const float* spec = m.specular();
+  const float* em = m.emission();
+
+  if (_current_shape_active) {
+    RenderColor(ACTIVE_COLOR);
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, ACTIVE_COLOR);
+  } else {
+    RenderColor(selection_color);
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, selection_color);
+  }
+  glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
+  glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
+  glMaterialfv(GL_FRONT, GL_EMISSION, em);
+  glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
+}
+
+void GLSelectRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
+{
+  unsigned int fIndex = 0;
+  
+  const real * vertices = ifs.vertices();
+  const real * normals = ifs.normals();
+  const Material *const* materials = ifs.materials();
+  const real * texCoords= ifs.texCoords();
+  const unsigned *vindices = ifs.vindices();
+  const unsigned *nindices = ifs.nindices();
+  const unsigned *mindices = ifs.mindices();
+  const unsigned *tindices = ifs.tindices();
+  const unsigned numfaces = ifs.numFaces();
+  const IndexedFaceSet::TRIANGLES_STYLE * faceStyle = ifs.trianglesStyle();
+  const unsigned *numVertexPerFace = ifs.numVertexPerFaces();
+  
+
+  const unsigned* pvi = vindices;
+  const unsigned* pni = nindices;
+  const unsigned* pmi = mindices;
+  const unsigned* pti = tindices;
+
+  for(fIndex=0; fIndex<numfaces; fIndex++)
+  {
+    switch(faceStyle[fIndex])
+    {
+    case IndexedFaceSet::TRIANGLE_STRIP:
+      RenderTriangleStrip(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLE_FAN:
+      RenderTriangleFan(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    case IndexedFaceSet::TRIANGLES:
+      RenderTriangles(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      break;
+    }
+    pvi += numVertexPerFace[fIndex];
+    pni += numVertexPerFace[fIndex];
+    pmi += numVertexPerFace[fIndex];
+    if(pti)
+        pti += numVertexPerFace[fIndex];
+  }
+}
+
+void GLSelectRenderer::visitNodeShapeBefore(NodeShape& sn) {
+  if (!_gl_select_rendering)
+    return;
+  
+  glPushName(sn.shapes()[0]->getId().getFirst());
+}
+
+void GLSelectRenderer::visitNodeShapeAfter(NodeShape& sn) {
+  if (!_gl_select_rendering)
+    return;
+
+  glPopName();
+}
diff --git a/source/blender/freestyle/intern/rendering/GLSelectRenderer.h b/source/blender/freestyle/intern/rendering/GLSelectRenderer.h
new file mode 100755
index 00000000000..bf8a334aebb
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLSelectRenderer.h
@@ -0,0 +1,85 @@
+//
+//  Filename         : GLSelectRenderer.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Class to highlight selected shapes
+//  Date of creation : 09/01/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GL_SELECT_RENDERER_H
+# define GL_SELECT_RENDERER_H
+
+# include "GLRenderer.h"
+
+class LIB_RENDERING_EXPORT GLSelectRenderer : public GLRenderer
+{
+ public:
+
+  inline GLSelectRenderer() : GLRenderer() {
+    _selected_shape = -1; // -1 means no selection
+    _current_shape_active = false;
+    _gl_select_rendering = false;
+  }
+  virtual ~GLSelectRenderer() {}
+
+  //
+  // visitClass methods
+  //
+  //////////////////////////////////////////////
+
+  VISIT_DECL(NodeShape)
+
+  VISIT_DECL(IndexedFaceSet)
+  VISIT_DECL(Material)
+
+  virtual void visitMaterial(const Material&);
+  virtual void visitNodeShapeBefore(NodeShape&);
+  virtual void visitNodeShapeAfter(NodeShape&);
+
+  void resetColor();
+
+  void setSelectedId(const int id) {
+    _selected_shape = id;
+  }
+
+  void setSelectRendering(bool b) {
+    _gl_select_rendering = b;
+  }
+
+  int getSelectedId() const {
+    return _selected_shape;
+  }
+
+  bool getSelectRendering() const {
+    return _gl_select_rendering;
+  }
+
+ private:
+
+  int		_selected_shape;
+  bool		_current_shape_active;
+  bool		_gl_select_rendering;
+};
+
+#endif // GL_SELECT_RENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLStrokeRenderer.cpp b/source/blender/freestyle/intern/rendering/GLStrokeRenderer.cpp
new file mode 100755
index 00000000000..5033cc5d895
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLStrokeRenderer.cpp
@@ -0,0 +1,550 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "GLStrokeRenderer.h"
+
+//soc
+// #include <qimage.h>
+// #include <qfileinfo.h>
+// #include <qgl.h>
+// #include <qfile.h>
+
+extern "C" {
+#include "BLI_blenlib.h"
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+}
+
+#include "../system/StringUtils.h"
+
+#ifdef WIN32
+# include "extgl.h"
+#endif // WIN32
+
+//#define glBlendEquation(x)
+
+GLStrokeRenderer::GLStrokeRenderer()
+:StrokeRenderer()
+{
+  _textureManager = new GLTextureManager;
+}
+
+GLStrokeRenderer::~GLStrokeRenderer()
+{
+  if(0 != _textureManager)
+  {
+    delete _textureManager;
+    _textureManager = 0;
+  }
+}
+
+float initialColor(float x, float avTex=0.5)
+{
+  float y=(1-x)/avTex;
+  return (y>1 ? 1 : y);
+}
+//float complementColor(float x, float avTex=0.5)
+//{
+//  float y=(1-x)/avTex-1;
+//  return (y<0 ? 0 : y);
+//}
+
+float complementColor(float x, float avTex=0.5)
+{
+  float y=(1-x);///avTex-1;
+  return (y<0 ? 0 : y);
+}
+
+void GLStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const
+{
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  Stroke::MediumType strokeType = iStrokeRep->getMediumType();
+  // int averageTextureAlpha=0.5; //default value
+  // if (strokeType==OIL_STROKE)
+    // averageTextureAlpha=0.75; 
+  // if (strokeType>=NO_BLEND_STROKE)
+    // averageTextureAlpha=1.0; 
+  // if (strokeType<0)
+    // {
+      // renderNoTexture(iStrokeRep);
+      // return;
+    // }
+  //soc unused - int i;
+  glDisable(GL_CULL_FACE);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  glDisable(GL_DEPTH_TEST);
+    
+  glEnable(GL_BLEND);
+
+  if(strokeType==Stroke::DRY_MEDIUM)
+    {
+      glBlendEquation(GL_MAX);
+    }
+  else if(strokeType==Stroke::OPAQUE_MEDIUM)
+    {
+      glBlendEquation(GL_ADD);
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    }
+  else
+    {
+      glBlendEquation(GL_ADD);
+      glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+    }
+  glEnable(GL_TEXTURE_2D);
+  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+  //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+  //first texture, basically the only one for lighter strokes
+  glBindTexture(GL_TEXTURE_2D, iStrokeRep->getTextureId()); 
+  //glBindTexture(GL_TEXTURE_2D, _textureManager.getPaperTextureIndex()); 
+  
+  vector<Strip*>& strips = iStrokeRep->getStrips();
+  for(vector<Strip*>::iterator s=strips.begin(), send=strips.end();
+  s!=send;
+  ++s){
+    Strip::vertex_container& vertices = (*s)->vertices();
+    glBegin(GL_TRIANGLE_STRIP);
+    for(Strip::vertex_container::iterator v=vertices.begin(), vend=vertices.end();
+    v!=vend;
+    ++v){
+      StrokeVertexRep * svRep = (*v);
+      Vec3r color = svRep->color();
+      real alpha = svRep->alpha();
+      glColor4f(complementColor(color[0]), 
+      complementColor(color[1]), 
+      complementColor(color[2]), alpha);
+      glTexCoord2f(svRep->texCoord()[0],svRep->texCoord()[1] );
+      glVertex2f(svRep->point2d()[0], svRep->point2d()[1]);
+    }  
+    glEnd();
+  }
+//  if (strokeType>=NO_BLEND_STROKE) return;
+  //  //return;
+  //
+  //  //second texture, the complement, for stronger strokes
+  //  glBindTexture(GL_TEXTURE_2D, _textureManager.getTextureIndex(2*strokeType+1)); 
+  //  glBegin(GL_TRIANGLE_STRIP);
+  //  for(i=0; i<_sizeStrip; i++)
+  //  {
+  //    glColor4f(complementColor(_color[i][0]), 
+  //      complementColor(_color[i][1]), 
+  //      complementColor(_color[i][2]), _alpha[i]);
+  //    glTexCoord2f(_texCoord[i][0],_texCoord[i][1] );
+  //    glVertex2f(_vertex[i][0], _vertex[i][1]);
+  //  }
+  //  glEnd();
+
+  glPopAttrib();
+}
+
+void GLStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) const
+{
+  glPushAttrib(GL_COLOR_BUFFER_BIT);
+  //soc unused - Stroke::MediumType strokeType = iStrokeRep->getMediumType();
+  //soc unused - int i;
+  glDisable(GL_CULL_FACE);
+  glDisable(GL_LIGHTING);
+  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+  glShadeModel(GL_SMOOTH);
+  glDisable(GL_DEPTH_TEST);
+    
+  glEnable(GL_BLEND);
+
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+  glEnable(GL_TEXTURE_2D);
+  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+  //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+  //first texture, basically the only one for lighter strokes
+  glBindTexture(GL_TEXTURE_2D, iStrokeRep->getTextureId()); 
+  //glBindTexture(GL_TEXTURE_2D, _textureManager.getPaperTextureIndex()); 
+  
+  vector<Strip*>& strips = iStrokeRep->getStrips();
+  for(vector<Strip*>::iterator s=strips.begin(), send=strips.end();
+  s!=send;
+  ++s){
+    Strip::vertex_container& vertices = (*s)->vertices();
+    glBegin(GL_TRIANGLE_STRIP);
+    for(Strip::vertex_container::iterator v=vertices.begin(), vend=vertices.end();
+    v!=vend;
+    ++v){
+      StrokeVertexRep * svRep = (*v);
+      Vec3r color = svRep->color();
+      real alpha = svRep->alpha();
+      glColor4f(color[0], 
+              color[1], 
+              color[2], alpha);
+      glTexCoord2f(svRep->texCoord()[0],svRep->texCoord()[1] );
+      glVertex2f(svRep->point2d()[0], svRep->point2d()[1]);
+    }  
+    glEnd();
+  }
+  glPopAttrib();
+}
+
+//No Texture
+//void GLStrokeRenderer::renderNoTexture(StrokeRep *iStrokeRep) const
+//{
+//  Stroke::MediumType strokeType = iStrokeRep->getMediumType();
+//  int sizeStrip = iStrokeRep->sizeStrip();
+//  const Vec3r *color = iStrokeRep->colors();
+//  const Vec2r *vertex = iStrokeRep->vertices();
+//  const float *alpha = iStrokeRep->alpha();
+//  
+//  glDisable(GL_LIGHTING);
+//  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+//  glShadeModel(GL_SMOOTH);
+//  glDisable(GL_DEPTH_TEST);
+//
+//  //if (strokeType==NO_TEXTURE_STROKE)
+//  if(strokeType < 0)
+//    {
+//      glDisable(GL_BLEND);
+//      glDisable(GL_TEXTURE_2D);
+//      glBegin(GL_TRIANGLE_STRIP);
+//      for(int i=0; i<sizeStrip; i++)
+//	{ 
+//	  glColor4f(complementColor(color[i][0]), 
+//		    complementColor(color[i][1]), 
+//		    complementColor(color[i][2]), alpha[i]);
+//	  glVertex2f(vertex[i][0], vertex[i][1]);
+//	} 
+//      glEnd();
+//    } 
+//  else
+//    {
+//      //#ifdef WIN32
+//      //glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+//      glBlendEquation(GL_ADD);
+//      //#endif
+//      glEnable(GL_BLEND);
+//      glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+//      glDisable(GL_TEXTURE_2D);
+//      glBegin(GL_TRIANGLE_STRIP);
+//      for(int i=0; i<sizeStrip; i++)
+//	{ 
+//	  glColor4f(complementColor(color[i][0]), 
+//		    complementColor(color[i][1]), 
+//		    complementColor(color[i][2]), alpha[i]);
+//	  glVertex2f(vertex[i][0], vertex[i][1]);
+//	} 
+//      glEnd();
+//    }
+//  //	cerr<<"color="<<_color[1][0]<<", "<<_color[1][1]<<", "<<_color[1][2]<<") "<<endl;
+//	
+//	
+//}
+
+
+/**********************************/
+/*                                */
+/*                                */
+/*         GLTextureManager         */
+/*                                */
+/*                                */
+/**********************************/
+
+//#define TEXTURES_DIR ROOT_DIR "/data/textures"
+
+GLTextureManager::GLTextureManager ()
+: TextureManager()
+{
+  //_brushes_path = Config::getInstance()...
+}
+
+GLTextureManager::~GLTextureManager ()
+{
+}
+
+void
+GLTextureManager::loadPapers ()
+{
+  unsigned size = _papertextures.size();
+  _papertexname = new unsigned[size];
+  GLuint *tmp = new GLuint[size];
+  glGenTextures(size, tmp);
+  for(unsigned i=0;i<size;++i){
+    _papertexname[i] = tmp[i];
+  }
+  delete [] tmp;
+
+  // Papers textures
+  cout << "Loading papers textures..." << endl;
+
+  for (unsigned i = 0; i < size; i++){
+	cout << i << ": " << _papertextures[i] << endl;
+	preparePaper(_papertextures[i].c_str(), _papertexname[i]);
+  }
+
+  cout << "Done." << endl << endl;
+}
+
+void GLTextureManager::loadStandardBrushes()
+{
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/charcoalAlpha.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/washbrushAlpha.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/oil.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/oilnoblend.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/charcoalAlpha.bmp", Stroke::DRY_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/washbrushAlpha.bmp", Stroke::DRY_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/opaqueDryBrushAlpha.bmp", Stroke::OPAQUE_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/opaqueBrushAlpha.bmp", Stroke::OPAQUE_MEDIUM);
+  _defaultTextureId = getBrushTextureIndex("smoothAlpha.bmp", Stroke::OPAQUE_MEDIUM);
+}
+
+
+unsigned
+GLTextureManager::loadBrush(string sname, Stroke::MediumType mediumType)
+{
+  GLuint texId;
+  glGenTextures(1, &texId);
+  bool found = false;
+  vector<string> pathnames;
+  string path; //soc
+  StringUtils::getPathName(TextureManager::Options::getBrushesPath(),
+  sname,
+  pathnames);
+  for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++) {
+    path = j->c_str();
+    //soc if(QFile::exists(path)){
+	if( BLI_exists( const_cast<char *>(path.c_str()) ) ) {
+      found = true;
+      break;
+    }
+  }
+  if(!found)
+    return 0;
+  // Brush texture
+  cout << "Loading brush texture..." << endl;
+  switch(mediumType){
+  case Stroke::DRY_MEDIUM:
+    //soc prepareTextureLuminance((const char*)path.toAscii(), texId);
+	prepareTextureLuminance(StringUtils::toAscii(path), texId);
+    break;
+  case Stroke::HUMID_MEDIUM:
+  case Stroke::OPAQUE_MEDIUM:
+  default:
+    //soc prepareTextureAlpha((const char*)path.toAscii(), texId);
+	prepareTextureAlpha(StringUtils::toAscii(path), texId);
+    break;
+  }
+  cout << "Done." << endl << endl;
+
+  return texId;
+}
+
+bool 
+GLTextureManager::prepareTextureAlpha (string sname, GLuint itexname)
+{
+  //soc const char * name = sname.c_str();
+	char * name = (char *) sname.c_str();
+	
+  //soc 
+  // QImage qim(name);
+  // QFileInfo fi(name);
+  // QString filename = fi.fileName();
+	ImBuf *qim = IMB_loadiffname(name, 0);
+	char filename[FILE_MAXFILE];
+	BLI_splitdirstring(name, filename);
+
+//soc  if (qim.isNull()) 
+  if (!qim) //soc 
+    {
+      cerr << "  Error: unable to read \"" << filename << "\"" << endl;
+	IMB_freeImBuf(qim);
+      return false;
+    }
+
+  if( qim->depth > 8) //soc
+    {
+      cerr<<"  Error: \""<< filename <<"\" has "<< qim->depth <<" bits/pixel"<<endl; //soc
+      return false;
+    }
+  //		qim=QGLWidget::convertToGLFormat( qimOri );
+
+  glBindTexture(GL_TEXTURE_2D, itexname);
+  //glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+		  GL_LINEAR);
+  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+  //	      GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		  GL_LINEAR);     
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, qim->x, qim->y, 0, 
+	       GL_ALPHA, GL_UNSIGNED_BYTE, qim->rect);	//soc
+
+  //soc cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;
+	cout << "  \"" << StringUtils::toAscii(filename) << "\" loaded with "<< qim->depth << " bits per pixel" << endl;
+	
+  return true;
+
+}
+
+bool 
+GLTextureManager::prepareTextureLuminance (string sname, GLuint itexname)
+{
+  //soc const char * name = sname.c_str();
+	char * name = (char *) sname.c_str();
+	
+  //soc
+  // QImage qim(name);
+  // QFileInfo fi(name);
+  // QString filename = fi.fileName();
+	ImBuf *qim = IMB_loadiffname(name, 0);
+	char filename[FILE_MAXFILE];
+	BLI_splitdirstring(name, filename);
+	
+  if (!qim) //soc 
+    {
+      cerr << "  Error: unable to read \"" << filename << "\"" << endl;
+	IMB_freeImBuf(qim);
+      return false;
+    }
+  if (qim->depth > 8) //soc
+    {
+      cerr<<"  Error: \""<<filename<<"\" has "<<qim->depth <<" bits/pixel"<<endl;//soc
+      return false;
+    }
+
+  glBindTexture(GL_TEXTURE_2D, itexname);
+  //glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+		  GL_LINEAR);
+  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+  //	      GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		  GL_LINEAR);     
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, qim->x, qim->y, 0, 
+	       GL_LUMINANCE, GL_UNSIGNED_BYTE, qim->rect);	//soc
+
+  //soc cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;
+	cout << "  \"" << StringUtils::toAscii(filename) << "\" loaded with "<< qim->depth << " bits per pixel" << endl;
+	
+  return true;
+
+}
+
+bool 
+GLTextureManager::prepareTextureLuminanceAndAlpha (string sname, GLuint itexname)
+{
+  //soc const char * name = sname.c_str();
+	char * name = (char *) sname.c_str();
+	
+  //soc
+  // QImage qim(name);
+  // QFileInfo fi(name);
+  // QString filename = fi.fileName();
+	ImBuf *qim = IMB_loadiffname(name, 0);
+	char filename[FILE_MAXFILE];
+	BLI_splitdirstring(name, filename);
+
+  if (!qim) //soc 
+    {
+      cerr << "  Error: unable to read \"" << filename << "\"" << endl;
+	IMB_freeImBuf(qim);
+      return false;
+    }
+
+  if (qim->depth > 8) //soc
+    {
+      cerr<<"  Error: \""<<filename<<"\" has "<< qim->depth <<" bits/pixel"<<endl; //soc
+      return false;
+    }
+					   
+  glBindTexture(GL_TEXTURE_2D, itexname);
+  //glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+					     
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+		  GL_LINEAR);
+  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+  //	      GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		  GL_LINEAR);     
+						     
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, qim->x, qim->y, 0, 
+	       GL_LUMINANCE, GL_UNSIGNED_BYTE, qim->rect);	//soc
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, qim->x, qim->y, 0, 
+	       GL_ALPHA, GL_UNSIGNED_BYTE, qim->rect);	//soc
+							 
+  //soc cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;						   
+	cout << "  \"" << StringUtils::toAscii(filename) << "\" loaded with "<< qim->depth << " bits per pixel" << endl;
+
+  return true;
+							     
+}
+
+bool 
+GLTextureManager::preparePaper (const char *name, GLuint itexname)
+{
+  //soc
+  // QImage qim(name);
+  // QFileInfo fi(name);
+  // QString filename = fi.fileName();
+	ImBuf *qim = IMB_loadiffname(name, 0);
+	char filename[FILE_MAXFILE];
+	BLI_splitdirstring((char *)name, filename);
+
+  if (!qim) //soc 
+    {
+      cerr << "  Error: unable to read \"" << filename << "\"" << endl;
+	IMB_freeImBuf(qim);
+      return false;
+    }
+
+	//soc: no test because IMB_loadiffname creates 32 bit image directly
+	//
+	//   if (qim->depth != 32) 
+	//     {
+	//       cerr<<"  Error: \""<<filename<<"\" has "<< qim->depth <<" bits/pixel"<<endl; //soc
+	// IMB_freeImBuf(qim);
+	//       return false;
+	//     }
+	// QImage qim2=QGLWidget::convertToGLFormat( qim );
+
+  glBindTexture(GL_TEXTURE_2D, itexname);
+	
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+		  GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+		  GL_LINEAR);     
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, qim->x, qim->y, 0, 
+	       GL_RGBA, GL_UNSIGNED_BYTE, qim->rect); // soc: was qim2
+
+  //cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;
+	cout << "  \"" << StringUtils::toAscii(filename) << "\" loaded with 32 bits per pixel" << endl;
+  return true;
+}
+
diff --git a/source/blender/freestyle/intern/rendering/GLStrokeRenderer.h b/source/blender/freestyle/intern/rendering/GLStrokeRenderer.h
new file mode 100755
index 00000000000..bef95996444
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLStrokeRenderer.h
@@ -0,0 +1,98 @@
+//
+//  Filename         : GLStrokeRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the GL stroke renderer.
+//  Date of creation : 05/03/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  GLSTROKERENDERER_H
+# define GLSTROKERENDERER_H
+
+# include "../system/FreestyleConfig.h"
+# include "../stroke/StrokeRenderer.h"
+# include "../stroke/StrokeRep.h"
+
+
+# ifdef WIN32
+#  include <windows.h>
+# endif
+# ifdef __MACH__
+#  include <OpenGL/gl.h>
+# else
+#  include <GL/gl.h>
+# endif
+
+/**********************************/
+/*                                */
+/*                                */
+/*         GLTextureManager       */
+/*                                */
+/*                                */
+/**********************************/
+
+/*! Class to load textures
+ */
+class LIB_RENDERING_EXPORT GLTextureManager : public TextureManager
+{
+ public:
+  GLTextureManager ();
+  virtual ~GLTextureManager ();
+protected:
+  virtual unsigned loadBrush(string fileName, Stroke::MediumType = Stroke::OPAQUE_MEDIUM);
+  
+ protected:
+  virtual void loadPapers();
+  virtual void loadStandardBrushes();
+  bool prepareTextureAlpha (string name, GLuint itexname);
+  bool prepareTextureLuminance (string name, GLuint itexname);
+  bool prepareTextureLuminanceAndAlpha (string name, GLuint itexname);
+  bool preparePaper (const char *name, GLuint itexname);
+};
+
+
+
+/**********************************/
+/*                                */
+/*                                */
+/*         GLStrokeRenderer       */
+/*                                */
+/*                                */
+/**********************************/
+
+class LIB_RENDERING_EXPORT GLStrokeRenderer : public StrokeRenderer
+{
+public:
+  GLStrokeRenderer();
+  virtual ~GLStrokeRenderer();
+
+  /*! Renders a stroke rep */
+  virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
+  virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;
+
+protected:
+  //void renderNoTexture(StrokeRep *iStrokeRep) const;
+};
+
+#endif // GLSTROKERENDERER_H
diff --git a/source/blender/freestyle/intern/rendering/GLUtils.cpp b/source/blender/freestyle/intern/rendering/GLUtils.cpp
new file mode 100755
index 00000000000..f086f86e2cd
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLUtils.cpp
@@ -0,0 +1,70 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "GLUtils.h"
+
+# ifdef WIN32
+#  include <windows.h>
+# endif
+# ifdef __MACH__
+#  include <OpenGL/gl.h>
+# else
+#  include <GL/gl.h>
+# endif
+#include <string.h>
+
+int isExtensionSupported(const char *extension)
+{
+  const GLubyte *extensions = NULL;
+  const GLubyte *start;
+  GLubyte *where, *terminator;
+
+  /* Extension names should not have spaces. */
+  where = (GLubyte *) strchr(extension, ' ');
+  if (where || *extension == '\0')
+    return 0;
+  extensions = glGetString(GL_EXTENSIONS);
+  /* It takes a bit of care to be fool-proof about parsing the
+     OpenGL extensions string. Don't be fooled by sub-strings,
+     etc. */
+  start = extensions;
+  for (;;) {
+    where = (GLubyte *) strstr((const char *) start, extension);
+    if (!where)
+      break;
+    terminator = where + strlen(extension);
+    if (where == start || *(where - 1) == ' ')
+      if (*terminator == ' ' || *terminator == '\0')
+        return 1;
+    start = terminator;
+  }
+  return 0;
+}
+
+void *glutils_extgl_GetProcAddress(const char *name)
+{
+#ifdef _WIN32
+    void *t = wglGetProcAddress(name);
+    return t;
+#else
+	return NULL;
+#endif
+}
+
diff --git a/source/blender/freestyle/intern/rendering/GLUtils.h b/source/blender/freestyle/intern/rendering/GLUtils.h
new file mode 100755
index 00000000000..453b3f31259
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLUtils.h
@@ -0,0 +1,29 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLUTILS_H
+#define GLUTILS_H
+
+#include "../system/FreestyleConfig.h"
+
+int LIB_RENDERING_EXPORT isExtensionSupported(const char *extension);
+void LIB_RENDERING_EXPORT *glutils_extgl_GetProcAddress(const char *name);
+
+#endif
diff --git a/source/blender/freestyle/intern/rendering/extgl.cpp b/source/blender/freestyle/intern/rendering/extgl.cpp
new file mode 100755
index 00000000000..d7207f21299
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/extgl.cpp
@@ -0,0 +1,2249 @@
+/* ----------------------------------------------------------------------------
+Copyright (c) 2001-2002, Lev Povalahev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, 
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, 
+      this list of conditions and the following disclaimer in the documentation 
+      and/or other materials provided with the distribution.
+    * The name of the author may be used to endorse or promote products 
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+THE POSSIBILITY OF SUCH DAMAGE.
+------------------------------------------------------------------------------*/
+/* 
+    Lev Povalahev
+
+    levp@gmx.net
+
+    http://www.uni-karlsruhe.de/~uli2/
+
+*/                         
+      
+#include "extgl.h"
+#include <stdio.h>
+#include <string.h>
+
+#ifndef _WIN32
+#include <GL/glx.h>
+#endif /* _WIN32 */
+
+/* turn off the warning for the borland compiler*/
+#ifdef __BORLANDC__
+#pragma warn -8064
+#pragma warn -8065
+#endif /* __BORLANDC__	*/
+
+/* function variables */
+
+/*-------------------------------------*/
+/* WGL stuff */
+/*-------------------------------------*/
+
+#ifdef _WIN32
+
+/* WGL_EXT_etxension_string */
+
+#ifdef WGL_EXT_extensions_string
+wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT = NULL;
+#endif /* WGL_EXT_extension_string */
+
+/* WGL_ARB_buffer_region */
+
+#ifdef WGL_ARB_buffer_region
+wglCreateBufferRegionARBPROC wglCreateBufferRegionARB = NULL;
+wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB = NULL;
+wglSaveBufferRegionARBPROC wglSaveBufferRegionARB = NULL;
+wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB = NULL;
+#endif /* WGL_ARB_buffer_region */
+
+/* WGL_ARB_extension_string */
+
+
+#ifdef WGL_ARB_extensions_string
+wglGetExtensionsStringARBPROC wglGetExtensionsStringARB = NULL;
+#endif /* WGL_ARB_extension_string */
+
+/* WGL_ARB_pbuffer */
+
+#ifdef WGL_ARB_pbuffer
+wglCreatePbufferARBPROC wglCreatePbufferARB = NULL;
+wglGetPbufferDCARBPROC wglGetPbufferDCARB = NULL;
+wglReleasePbufferDCARBPROC wglReleasePbufferDCARB = NULL;
+wglDestroyPbufferARBPROC wglDestroyPbufferARB = NULL;
+wglQueryPbufferARBPROC wglQueryPbufferARB = NULL;
+#endif /* WGL_ARB_pbuffer */
+
+/* WGL_ARB_pixel_format */
+
+#ifdef WGL_ARB_pixel_format
+wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB = NULL;
+wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB = NULL;
+wglChoosePixelFormatARBPROC wglChoosePixelFormatARB = NULL;
+#endif /* WGL_ARB_pixel_format */
+
+/* WGL_ARB_render_texture */
+
+#ifdef WGL_ARB_render_texture
+wglBindTexImageARBPROC wglBindTexImageARB = NULL;
+wglReleaseTexImageARBPROC wglReleaseTexImageARB = NULL;
+wglSetPbufferAttribARBPROC wglSetPbufferAttribARB = NULL;
+#endif /* WGL_ARB_render_texture */
+
+/* WGL_EXT_swap_control */
+
+#ifdef WGL_EXT_swap_control
+wglSwapIntervalEXTPROC wglSwapIntervalEXT = NULL;
+wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT = NULL;
+#endif /* WGL_EXT_swap_control */
+
+/* WGL_ARB_make_current_read */
+
+#ifdef WGL_ARB_make_current_read
+wglMakeContextCurrentARBPROC wglMakeContextCurrentARB = NULL;
+wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB = NULL;
+#endif /* WGL_ARB_make_current_read*/ 
+
+/* VAR */
+
+#endif /* WIN32 */
+
+/*-------------------------------------*/
+/*---WGL STUFF END---------------------*/
+/*-------------------------------------*/
+
+#ifdef _WIN32
+
+#ifdef GL_VERSION_1_2
+glDrawRangeElementsPROC glDrawRangeElements = NULL;
+glTexImage3DPROC glTexImage3D = NULL;
+glTexSubImage3DPROC glTexSubImage3D = NULL;
+glCopyTexSubImage3DPROC glCopyTexSubImage3D = NULL;
+#endif /* GL_VERSION_1_2 */
+
+#ifdef GL_ARB_imaging
+glBlendColorPROC glBlendColor = NULL;
+LIB_RENDERING_EXPORT
+glBlendEquationPROC glBlendEquation = NULL;
+glColorTablePROC glColorTable = NULL;
+glColorTableParameterfvPROC glColorTableParameterfv = NULL;
+glColorTableParameterivPROC glColorTableParameteriv = NULL;
+glCopyColorTablePROC glCopyColorTable = NULL;
+glGetColorTablePROC glGetColorTable = NULL;
+glGetColorTableParameterfvPROC glGetColorTableParameterfv = NULL;
+glGetColorTableParameterivPROC glGetColorTableParameteriv = NULL;
+glColorSubTablePROC glColorSubTable = NULL;
+glCopyColorSubTablePROC glCopyColorSubTable = NULL;
+glConvolutionFilter1DPROC glConvolutionFilter1D = NULL;
+glConvolutionFilter2DPROC glConvolutionFilter2D = NULL;
+glConvolutionParameterfPROC glConvolutionParameterf = NULL;
+glConvolutionParameterfvPROC glConvolutionParameterfv = NULL;
+glConvolutionParameteriPROC glConvolutionParameteri = NULL;
+glConvolutionParameterivPROC glConvolutionParameteriv = NULL;
+glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D = NULL;
+glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D = NULL;
+glGetConvolutionFilterPROC glGetConvolutionFilter = NULL;
+glGetConvolutionParameterfvPROC glGetConvolutionParameterfv = NULL;
+glGetConvolutionParameterivPROC glGetConvolutionParameteriv = NULL;
+glGetSeparableFilterPROC glGetSeparableFilter = NULL;
+glSeparableFilter2DPROC glSeparableFilter2D = NULL;
+glGetHistogramPROC glGetHistogram = NULL;
+glGetHistogramParameterfvPROC glGetHistogramParameterfv = NULL;
+glGetHistogramParameterivPROC glGetHistogramParameteriv = NULL;
+glGetMinmaxPROC glGetMinmax = NULL;
+glGetMinmaxParameterfvPROC glGetMinmaxParameterfv = NULL;
+glGetMinmaxParameterivPROC glGetMinmaxParameteriv = NULL;
+glHistogramPROC glHistogram = NULL;
+glMinmaxPROC glMinmax = NULL;
+glResetHistogramPROC glResetHistogram = NULL;
+glResetMinmaxPROC glResetMinmax = NULL;
+#endif /* GL_ARB_imaging */
+
+/* 1.3 */
+
+#ifdef GL_VERSION_1_3
+glActiveTexturePROC glActiveTexture = NULL;
+glClientActiveTexturePROC glClientActiveTexture = NULL;
+glMultiTexCoord1dPROC glMultiTexCoord1d = NULL;
+glMultiTexCoord1dvPROC glMultiTexCoord1dv = NULL;
+glMultiTexCoord1fPROC glMultiTexCoord1f = NULL;
+glMultiTexCoord1fvPROC glMultiTexCoord1fv = NULL;
+glMultiTexCoord1iPROC glMultiTexCoord1i = NULL;
+glMultiTexCoord1ivPROC glMultiTexCoord1iv = NULL;
+glMultiTexCoord1sPROC glMultiTexCoord1s = NULL;
+glMultiTexCoord1svPROC glMultiTexCoord1sv = NULL;
+glMultiTexCoord2dPROC glMultiTexCoord2d = NULL;
+glMultiTexCoord2dvPROC glMultiTexCoord2dv = NULL;
+glMultiTexCoord2fPROC glMultiTexCoord2f = NULL;
+glMultiTexCoord2fvPROC glMultiTexCoord2fv = NULL;
+glMultiTexCoord2iPROC glMultiTexCoord2i = NULL;
+glMultiTexCoord2ivPROC glMultiTexCoord2iv = NULL;
+glMultiTexCoord2sPROC glMultiTexCoord2s = NULL;
+glMultiTexCoord2svPROC glMultiTexCoord2sv = NULL;
+glMultiTexCoord3dPROC glMultiTexCoord3d = NULL;
+glMultiTexCoord3dvPROC glMultiTexCoord3dv = NULL;
+glMultiTexCoord3fPROC glMultiTexCoord3f = NULL;
+glMultiTexCoord3fvPROC glMultiTexCoord3fv = NULL;
+glMultiTexCoord3iPROC glMultiTexCoord3i = NULL;
+glMultiTexCoord3ivPROC glMultiTexCoord3iv = NULL;
+glMultiTexCoord3sPROC glMultiTexCoord3s = NULL;
+glMultiTexCoord3svPROC glMultiTexCoord3sv = NULL;
+glMultiTexCoord4dPROC glMultiTexCoord4d = NULL;
+glMultiTexCoord4dvPROC glMultiTexCoord4dv = NULL;
+glMultiTexCoord4fPROC glMultiTexCoord4f = NULL;
+glMultiTexCoord4fvPROC glMultiTexCoord4fv = NULL;
+glMultiTexCoord4iPROC glMultiTexCoord4i = NULL;
+glMultiTexCoord4ivPROC glMultiTexCoord4iv = NULL;
+glMultiTexCoord4sPROC glMultiTexCoord4s = NULL;
+glMultiTexCoord4svPROC glMultiTexCoord4sv = NULL;
+glLoadTransposeMatrixfPROC glLoadTransposeMatrixf = NULL;
+glLoadTransposeMatrixdPROC glLoadTransposeMatrixd = NULL;
+glMultTransposeMatrixfPROC glMultTransposeMatrixf = NULL;
+glMultTransposeMatrixdPROC glMultTransposeMatrixd = NULL;
+glCompressedTexImage3DPROC glCompressedTexImage3D = NULL;
+glCompressedTexImage2DPROC glCompressedTexImage2D = NULL;
+glCompressedTexImage1DPROC glCompressedTexImage1D = NULL;
+glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = NULL;
+glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = NULL;
+glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = NULL;
+glGetCompressedTexImagePROC glGetCompressedTexImage = NULL;
+glSampleCoveragePROC glSampleCoverage = NULL;
+#endif /* GL_VERSION_1_3 */
+
+/* ARB_multitexture */
+
+#ifdef GL_ARB_multitexture
+glActiveTextureARBPROC glActiveTextureARB = NULL;
+glClientActiveTextureARBPROC glClientActiveTextureARB = NULL;
+glMultiTexCoord1dARBPROC glMultiTexCoord1dARB = NULL;
+glMultiTexCoord1dvARBPROC glMultiTexCoord1dvARB = NULL;
+glMultiTexCoord1fARBPROC glMultiTexCoord1fARB = NULL;
+glMultiTexCoord1fvARBPROC glMultiTexCoord1fvARB = NULL;
+glMultiTexCoord1iARBPROC glMultiTexCoord1iARB = NULL;
+glMultiTexCoord1ivARBPROC glMultiTexCoord1ivARB = NULL;
+glMultiTexCoord1sARBPROC glMultiTexCoord1sARB = NULL;
+glMultiTexCoord1svARBPROC glMultiTexCoord1svARB = NULL;
+glMultiTexCoord2dARBPROC glMultiTexCoord2dARB = NULL;
+glMultiTexCoord2dvARBPROC glMultiTexCoord2dvARB = NULL;
+glMultiTexCoord2fARBPROC glMultiTexCoord2fARB = NULL;
+glMultiTexCoord2fvARBPROC glMultiTexCoord2fvARB = NULL;
+glMultiTexCoord2iARBPROC glMultiTexCoord2iARB = NULL;
+glMultiTexCoord2ivARBPROC glMultiTexCoord2ivARB = NULL;
+glMultiTexCoord2sARBPROC glMultiTexCoord2sARB = NULL;
+glMultiTexCoord2svARBPROC glMultiTexCoord2svARB = NULL;
+glMultiTexCoord3dARBPROC glMultiTexCoord3dARB = NULL;
+glMultiTexCoord3dvARBPROC glMultiTexCoord3dvARB = NULL;
+glMultiTexCoord3fARBPROC glMultiTexCoord3fARB = NULL;
+glMultiTexCoord3fvARBPROC glMultiTexCoord3fvARB = NULL;
+glMultiTexCoord3iARBPROC glMultiTexCoord3iARB = NULL;
+glMultiTexCoord3ivARBPROC glMultiTexCoord3ivARB = NULL;
+glMultiTexCoord3sARBPROC glMultiTexCoord3sARB = NULL;
+glMultiTexCoord3svARBPROC glMultiTexCoord3svARB = NULL;
+glMultiTexCoord4dARBPROC glMultiTexCoord4dARB = NULL;
+glMultiTexCoord4dvARBPROC glMultiTexCoord4dvARB = NULL;
+glMultiTexCoord4fARBPROC glMultiTexCoord4fARB = NULL;
+glMultiTexCoord4fvARBPROC glMultiTexCoord4fvARB = NULL;
+glMultiTexCoord4iARBPROC glMultiTexCoord4iARB = NULL;
+glMultiTexCoord4ivARBPROC glMultiTexCoord4ivARB = NULL;
+glMultiTexCoord4sARBPROC glMultiTexCoord4sARB = NULL;
+glMultiTexCoord4svARBPROC glMultiTexCoord4svARB = NULL;
+#endif /* GL_ARB_multitexture */
+
+#endif /* WIN32 */
+
+/* ARB_transpose_matrix */
+
+#ifdef GL_ARB_transpose_matrix
+glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB = NULL;
+glLoadTransposeMatrixdARBPROC glLoadTransposeMatrixdARB = NULL;
+glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB = NULL;
+glMultTransposeMatrixdARBPROC glMultTransposeMatrixdARB = NULL;
+#endif /* GL_ARB_transpose_matrix */
+
+/* ARB_texture_compression */
+
+#ifdef GL_ARB_texture_compression 
+glCompressedTexImage3DARBPROC glCompressedTexImage3DARB = NULL;
+glCompressedTexImage2DARBPROC glCompressedTexImage2DARB = NULL;
+glCompressedTexImage1DARBPROC glCompressedTexImage1DARB = NULL; 
+glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB = NULL;
+glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB = NULL;
+glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB = NULL;
+glGetCompressedTexImageARBPROC glGetCompressedTexImageARB = NULL;
+#endif /* GL_ARB_texture_compression */
+
+/* EXT_secondary_color */
+
+#ifdef GL_EXT_secondary_color
+glSecondaryColor3bEXTPROC glSecondaryColor3bEXT = NULL;
+glSecondaryColor3bvEXTPROC glSecondaryColor3bvEXT = NULL;
+glSecondaryColor3dEXTPROC glSecondaryColor3dEXT = NULL;
+glSecondaryColor3dvEXTPROC glSecondaryColor3dvEXT = NULL;
+glSecondaryColor3fEXTPROC glSecondaryColor3fEXT = NULL;
+glSecondaryColor3fvEXTPROC glSecondaryColor3fvEXT = NULL;
+glSecondaryColor3iEXTPROC glSecondaryColor3iEXT = NULL;
+glSecondaryColor3ivEXTPROC glSecondaryColor3ivEXT = NULL;
+glSecondaryColor3sEXTPROC glSecondaryColor3sEXT = NULL;
+glSecondaryColor3svEXTPROC glSecondaryColor3svEXT = NULL;
+glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT = NULL;
+glSecondaryColor3ubvEXTPROC glSecondaryColor3ubvEXT = NULL;
+glSecondaryColor3uiEXTPROC glSecondaryColor3uiEXT = NULL;
+glSecondaryColor3uivEXTPROC glSecondaryColor3uivEXT = NULL;
+glSecondaryColor3usEXTPROC glSecondaryColor3usEXT = NULL;
+glSecondaryColor3usvEXTPROC glSecondaryColor3usvEXT = NULL;
+glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT = NULL;
+#endif /* GL_EXT_secondary_color */
+
+/* EXT_compiled_vertex_array */
+
+#ifdef GL_EXT_compiled_vertex_array 
+glLockArraysEXTPROC glLockArraysEXT = NULL;
+glUnlockArraysEXTPROC glUnlockArraysEXT = NULL;
+#endif /* GL_EXT_compiled_vertex_array */
+
+/* EXT_fog_coord */
+
+#ifdef GL_EXT_fog_coord
+glFogCoordfEXTPROC glFogCoordfEXT = NULL;
+glFogCoordfvEXTPROC glFogCoordfvEXT = NULL;
+glFogCoorddEXTPROC glFogCoorddEXT = NULL;
+glFogCoorddvEXTPROC glFogCoorddvEXT = NULL;
+glFogCoordPointerEXTPROC glFogCoordPointerEXT = NULL;
+#endif /* GL_EXT_for_color */
+
+/* NV_vertex_array_range */
+
+#ifdef GL_NV_vertex_array_range
+glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV = NULL;
+glVertexArrayRangeNVPROC glVertexArrayRangeNV = NULL;
+
+#ifdef _WIN32
+wglAllocateMemoryNVPROC wglAllocateMemoryNV = NULL;
+wglFreeMemoryNVPROC wglFreeMemoryNV = NULL;
+#else
+glXAllocateMemoryNVPROC glXAllocateMemoryNV = NULL;
+glXFreeMemoryNVPROC glXFreeMemoryNV = NULL;
+#endif /* WIN32 */
+
+#endif /* GL_NV_vertex_array_range */
+
+/* EXT_point_parameters */
+
+#ifdef GL_EXT_point_parameters
+glPointParameterfEXTPROC glPointParameterfEXT = NULL;
+glPointParameterfvEXTPROC glPointParameterfvEXT = NULL;
+#endif /* GL_EXT_point_parameters */
+
+/* NV_register_combiners */
+
+#ifdef GL_NV_register_combiners
+glCombinerParameterfvNVPROC glCombinerParameterfvNV = NULL;
+glCombinerParameterfNVPROC  glCombinerParameterfNV = NULL;
+glCombinerParameterivNVPROC glCombinerParameterivNV = NULL;
+glCombinerParameteriNVPROC glCombinerParameteriNV = NULL;
+glCombinerInputNVPROC glCombinerInputNV = NULL;
+glCombinerOutputNVPROC glCombinerOutputNV = NULL;
+glFinalCombinerInputNVPROC glFinalCombinerInputNV = NULL;
+glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV = NULL;
+glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV = NULL;
+glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV = NULL;
+glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV = NULL;
+glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV = NULL;
+glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV = NULL;
+#endif /* GL_NV_register_combiners */
+
+/* ARB_multisample */
+
+#ifdef GL_ARB_multisample
+glSampleCoverageARBPROC glSampleCoverageARB = NULL;
+#endif /* GL_ARB_multisample */
+
+/* EXT_vertex_weighting */
+
+#ifdef GL_EXT_vertex_weighting
+glVertexWeightfEXTPROC glVertexWeightfEXT = NULL;
+glVertexWeightfvEXTPROC glVertexWeightfvEXT = NULL;
+glVertexWeightPointerEXTPROC glVertexWeightPointerEXT = NULL;
+#endif /* GL_EXT_vertex_weighting */
+
+/* NV_vertex_program */
+
+#ifdef GL_NV_vertex_program
+glBindProgramNVPROC glBindProgramNV = NULL;
+glDeleteProgramsNVPROC glDeleteProgramsNV = NULL;
+glExecuteProgramNVPROC glExecuteProgramNV = NULL;
+glGenProgramsNVPROC glGenProgramsNV = NULL;
+glAreProgramsResidentNVPROC glAreProgramsResidentNV = NULL;
+glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = NULL;
+glGetProgramParameterfvNVPROC glGetProgramParameterfvNV = NULL;
+glGetProgramParameterdvNVPROC glGetProgramParameterdvNV = NULL;
+glGetProgramivNVPROC glGetProgramivNV = NULL;
+glGetProgramStringNVPROC glGetProgramStringNV = NULL;
+glGetTrackMatrixivNVPROC glGetTrackMatrixivNV = NULL;
+glGetVertexAttribdvNVPROC glGetVertexAttribdvNV = NULL;
+glGetVertexAttribfvNVPROC glGetVertexAttribfvNV = NULL;
+glGetVertexAttribivNVPROC glGetVertexAttribivNV = NULL;
+glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV = NULL;
+glIsProgramNVPROC glIsProgramNV = NULL;
+glLoadProgramNVPROC glLoadProgramNV = NULL;
+glProgramParameter4fNVPROC glProgramParameter4fNV = NULL;
+glProgramParameter4dNVPROC glProgramParameter4dNV = NULL;
+glProgramParameter4dvNVPROC glProgramParameter4dvNV = NULL;
+glProgramParameter4fvNVPROC glProgramParameter4fvNV = NULL;
+glProgramParameters4dvNVPROC glProgramParameters4dvNV = NULL;
+glProgramParameters4fvNVPROC glProgramParameters4fvNV = NULL;
+glTrackMatrixNVPROC glTrackMatrixNV = NULL;
+glVertexAttribPointerNVPROC glVertexAttribPointerNV = NULL;
+glVertexAttrib1sNVPROC glVertexAttrib1sNV = NULL;
+glVertexAttrib1fNVPROC glVertexAttrib1fNV = NULL;
+glVertexAttrib1dNVPROC glVertexAttrib1dNV = NULL;
+glVertexAttrib2sNVPROC glVertexAttrib2sNV = NULL;
+glVertexAttrib2fNVPROC glVertexAttrib2fNV = NULL;
+glVertexAttrib2dNVPROC glVertexAttrib2dNV = NULL;
+glVertexAttrib3sNVPROC glVertexAttrib3sNV = NULL;
+glVertexAttrib3fNVPROC glVertexAttrib3fNV = NULL;
+glVertexAttrib3dNVPROC glVertexAttrib3dNV = NULL;
+glVertexAttrib4sNVPROC glVertexAttrib4sNV = NULL;
+glVertexAttrib4fNVPROC glVertexAttrib4fNV = NULL;
+glVertexAttrib4dNVPROC glVertexAttrib4dNV = NULL;
+glVertexAttrib4ubNVPROC glVertexAttrib4ubNV = NULL;
+glVertexAttrib1svNVPROC glVertexAttrib1svNV = NULL;
+glVertexAttrib1fvNVPROC glVertexAttrib1fvNV = NULL;
+glVertexAttrib1dvNVPROC glVertexAttrib1dvNV = NULL;
+glVertexAttrib2svNVPROC glVertexAttrib2svNV = NULL;
+glVertexAttrib2fvNVPROC glVertexAttrib2fvNV = NULL;
+glVertexAttrib2dvNVPROC glVertexAttrib2dvNV = NULL;
+glVertexAttrib3svNVPROC glVertexAttrib3svNV = NULL;
+glVertexAttrib3fvNVPROC glVertexAttrib3fvNV = NULL;
+glVertexAttrib3dvNVPROC glVertexAttrib3dvNV = NULL;
+glVertexAttrib4svNVPROC glVertexAttrib4svNV = NULL;
+glVertexAttrib4fvNVPROC glVertexAttrib4fvNV = NULL;
+glVertexAttrib4dvNVPROC glVertexAttrib4dvNV = NULL;
+glVertexAttrib4ubvNVPROC glVertexAttrib4ubvNV = NULL;
+glVertexAttribs1svNVPROC glVertexAttribs1svNV = NULL;
+glVertexAttribs1fvNVPROC glVertexAttribs1fvNV = NULL;
+glVertexAttribs1dvNVPROC glVertexAttribs1dvNV = NULL;
+glVertexAttribs2svNVPROC glVertexAttribs2svNV = NULL;
+glVertexAttribs2fvNVPROC glVertexAttribs2fvNV = NULL;
+glVertexAttribs2dvNVPROC glVertexAttribs2dvNV = NULL;
+glVertexAttribs3svNVPROC glVertexAttribs3svNV = NULL;
+glVertexAttribs3fvNVPROC glVertexAttribs3fvNV = NULL;
+glVertexAttribs3dvNVPROC glVertexAttribs3dvNV = NULL;
+glVertexAttribs4svNVPROC glVertexAttribs4svNV = NULL;
+glVertexAttribs4fvNVPROC glVertexAttribs4fvNV = NULL;
+glVertexAttribs4dvNVPROC glVertexAttribs4dvNV = NULL;
+glVertexAttribs4ubvNVPROC glVertexAttribs4ubvNV = NULL;
+#endif /* GL_NV_vertex_program */
+
+/* NV_fence */
+
+#ifdef GL_NV_fence
+glGenFencesNVPROC glGenFencesNV = NULL;
+glDeleteFencesNVPROC glDeleteFencesNV = NULL;
+glSetFenceNVPROC glSetFenceNV = NULL;
+glTestFenceNVPROC glTestFenceNV = NULL;
+glFinishFenceNVPROC glFinishFenceNV = NULL;
+glIsFenceNVPROC glIsFenceNV = NULL;
+glGetFenceivNVPROC glGetFenceivNV = NULL;
+#endif /* GL_NV_fence */
+
+/* NV_register_combiners2 */
+
+#ifdef GL_NV_register_combiners2
+glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV = NULL;
+glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV = NULL;
+#endif /* GL_NV_register_combiners2 */
+
+/* NV_evaluators */
+
+#ifdef GL_NV_evaluators
+glMapControlPointsNVPROC glMapControlPointsNV = NULL;
+glMapParameterivNVPROC glMapParameterivNV = NULL;
+glMapParameterfvNVPROC glMapParameterfvNV = NULL;
+glGetMapControlPointsNVPROC glGetMapControlPointsNV = NULL;
+glGetMapParameterivNVPROC glGetMapParameterivNV = NULL;
+glGetMapParameterfvNVPROC glGetMapParameterfvNV = NULL;
+glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV = NULL;
+glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV = NULL;
+glEvalMapsNVPROC glEvalMapsNV = NULL;
+#endif /* GL_NV_evaluators */
+
+/* ATI_pn_triangles */
+
+#ifdef GL_ATI_pn_triangles 
+glPNTrianglesiATIPROC glPNTrianglesiATI = NULL;
+glPNTrianglesfATIPROC glPNTrianglesfATI = NULL;
+#endif /* GL_ATI_pn_triangles */
+
+/* ARB_point_parameters */
+
+#ifdef GL_ARB_point_parameters
+glPointParameterfARBPROC glPointParameterfARB = NULL;
+glPointParameterfvARBPROC glPointParameterfvARB = NULL;
+#endif /* GL_ABR_point_parameters */
+
+/* ARB_vertex_blend */
+
+#ifdef GL_ARB_vertex_blend
+glWeightbvARBPROC glWeightbvARB = NULL;
+glWeightsvARBPROC glWeightsvARB = NULL;
+glWeightivARBPROC glWeightivARB = NULL;
+glWeightfvARBPROC glWeightfvARB = NULL;
+glWeightdvARBPROC glWeightdvARB = NULL;
+glWeightubvARBPROC glWeightubvARB = NULL;
+glWeightusvARBPROC glWeightusvARB = NULL;
+glWeightuivARBPROC glWeightuivARB = NULL;
+glWeightPointerARBPROC glWeightPointerARB = NULL;
+glVertexBlendARBPROC glVertexBlendARB = NULL;
+#endif /* GL_ARB_vertex_blend */
+
+/* EXT_multi_draw_arrays */
+
+#ifdef GL_EXT_multi_draw_arrays
+glMultiDrawArraysEXTPROC glMultiDrawArraysEXT = NULL;
+glMultiDrawElementsEXTPROC glMultiDrawElementsEXT = NULL;
+#endif /* GL_EXT_multi_draw_arrays */
+
+/* ARB_matrix_palette */
+
+#ifdef GL_ARB_matrix_palette
+glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB = NULL;
+glMatrixIndexubvARBPROC glMatrixIndexubvARB = NULL;
+glMatrixIndexusvARBPROC glMatrixIndexusvARB = NULL;
+glMatrixIndexuivARBPROC glMatrixIndexuivARB = NULL;
+glMatrixIndexPointerARBPROC glMatrixIndexPointerARB = NULL;
+#endif /* GL_ARB_matrix_palette */
+
+/* EXT_vertex_shader */
+
+#ifdef GL_EXT_vertex_shader
+glBeginVertexShaderEXTPROC glBeginVertexShaderEXT = NULL;
+glEndVertexShaderEXTPROC glEndVertexShaderEXT = NULL;
+glBindVertexShaderEXTPROC glBindVertexShaderEXT = NULL;
+glGenVertexShadersEXTPROC glGenVertexShadersEXT = NULL;
+glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT = NULL;
+glShaderOp1EXTPROC glShaderOp1EXT = NULL;
+glShaderOp2EXTPROC glShaderOp2EXT = NULL;
+glShaderOp3EXTPROC glShaderOp3EXT = NULL;
+glSwizzleEXTPROC glSwizzleEXT = NULL;
+glWriteMaskEXTPROC glWriteMaskEXT = NULL;
+glInsertComponentEXTPROC glInsertComponentEXT = NULL;
+glExtractComponentEXTPROC glExtractComponentEXT = NULL;
+glGenSymbolsEXTPROC glGenSymbolsEXT = NULL;
+glSetInvariantEXTPROC glSetInvariantEXT = NULL;
+glSetLocalConstantEXTPROC glSetLocalConstantEXT = NULL;
+glVariantbvEXTPROC glVariantbvEXT = NULL;
+glVariantsvEXTPROC glVariantsvEXT = NULL;
+glVariantivEXTPROC glVariantivEXT = NULL;
+glVariantfvEXTPROC glVariantfvEXT = NULL;
+glVariantdvEXTPROC glVariantdvEXT = NULL;
+glVariantubvEXTPROC glVariantubvEXT = NULL;
+glVariantusvEXTPROC glVariantusvEXT = NULL;
+glVariantuivEXTPROC glVariantuivEXT = NULL;
+glVariantPointerEXTPROC glVariantPointerEXT = NULL;
+glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT = NULL;
+glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT = NULL;
+glBindLightParameterEXTPROC glBindLightParameterEXT = NULL;
+glBindMaterialParameterEXTPROC glBindMaterialParameterEXT = NULL;
+glBindTexGenParameterEXTPROC glBindTexGenParameterEXT = NULL;
+glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT = NULL;
+glBindParameterEXTPROC glBindParameterEXT = NULL;
+glIsVariantEnabledEXTPROC glIsVariantEnabledEXT = NULL;
+glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT = NULL;
+glGetVariantIntegervEXTPROC glGetVariantIntegervEXT = NULL;
+glGetVariantFloatvEXTPROC glGetVariantFloatvEXT = NULL;
+glGetVariantPointervEXTPROC glGetVariantPointervEXT = NULL;
+glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT = NULL;
+glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT = NULL;
+glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT = NULL;
+glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT = NULL;
+glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT = NULL;
+glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT = NULL;
+#endif /* GL_EXT_vertex_shader */
+
+/* ATI_envmap_bumpmap */
+
+#ifdef GL_ATI_envmap_bumpmap
+glTexBumpParameterivATIPROC glTexBumpParameterivATI = NULL;
+glTexBumpParameterfvATIPROC glTexBumpParameterfvATI = NULL;
+glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI = NULL;
+glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI = NULL;
+#endif /* GL_ATI_envmap_bumpmap */
+
+/* ATI_fragment_shader */
+
+#ifdef GL_ATI_fragment_shader
+glGenFragmentShadersATIPROC glGenFragmentShadersATI = NULL;
+glBindFragmentShaderATIPROC glBindFragmentShaderATI = NULL;
+glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI = NULL;
+glBeginFragmentShaderATIPROC glBeginFragmentShaderATI = NULL;
+glEndFragmentShaderATIPROC glEndFragmentShaderATI = NULL;
+glPassTexCoordATIPROC glPassTexCoordATI = NULL;
+glSampleMapATIPROC glSampleMapATI = NULL;
+glColorFragmentOp1ATIPROC glColorFragmentOp1ATI = NULL;
+glColorFragmentOp2ATIPROC glColorFragmentOp2ATI = NULL;
+glColorFragmentOp3ATIPROC glColorFragmentOp3ATI = NULL;
+glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI = NULL;
+glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI = NULL;
+glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI = NULL;
+glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI = NULL;
+#endif /* GL_ATI_fragment_shader */
+
+/* ATI_element_array */
+
+#ifdef GL_ATI_element_array 
+glElementPointerATIPROC glElementPointerATI = NULL;
+glDrawElementArrayATIPROC glDrawElementArrayATI = NULL;
+glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = NULL;
+#endif /* GL_ATI_element_array */
+
+/* ATI_vertex_streams */
+
+#ifdef GL_ATI_vertex_streams
+glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI = NULL;
+glVertexBlendEnviATIPROC glVertexBlendEnviATI = NULL;
+glVertexBlendEnvfATIPROC glVertexBlendEnvfATI = NULL;
+glVertexStream2sATIPROC glVertexStream2sATI = NULL;
+glVertexStream2svATIPROC glVertexStream2svATI = NULL;
+glVertexStream2iATIPROC glVertexStream2iATI = NULL;
+glVertexStream2ivATIPROC glVertexStream2ivATI = NULL;
+glVertexStream2fATIPROC glVertexStream2fATI = NULL;
+glVertexStream2fvATIPROC glVertexStream2fvATI = NULL;
+glVertexStream2dATIPROC glVertexStream2dATI = NULL;
+glVertexStream2dvATIPROC glVertexStream2dvATI = NULL;
+glVertexStream3sATIPROC glVertexStream3sATI = NULL;
+glVertexStream3svATIPROC glVertexStream3svATI = NULL;
+glVertexStream3iATIPROC glVertexStream3iATI = NULL;
+glVertexStream3ivATIPROC glVertexStream3ivATI = NULL;
+glVertexStream3fATIPROC glVertexStream3fATI = NULL;
+glVertexStream3fvATIPROC glVertexStream3fvATI = NULL;
+glVertexStream3dATIPROC glVertexStream3dATI = NULL;
+glVertexStream3dvATIPROC glVertexStream3dvATI = NULL;
+glVertexStream4sATIPROC glVertexStream4sATI = NULL;
+glVertexStream4svATIPROC glVertexStream4svATI = NULL;
+glVertexStream4iATIPROC glVertexStream4iATI = NULL;
+glVertexStream4ivATIPROC glVertexStream4ivATI = NULL;
+glVertexStream4fATIPROC glVertexStream4fATI = NULL;
+glVertexStream4fvATIPROC glVertexStream4fvATI = NULL;
+glVertexStream4dATIPROC glVertexStream4dATI = NULL;
+glVertexStream4dvATIPROC glVertexStream4dvATI = NULL;
+glNormalStream3bATIPROC glNormalStream3bATI = NULL;
+glNormalStream3bvATIPROC glNormalStream3bvATI = NULL;
+glNormalStream3sATIPROC glNormalStream3sATI = NULL;
+glNormalStream3svATIPROC glNormalStream3svATI = NULL;
+glNormalStream3iATIPROC glNormalStream3iATI = NULL;
+glNormalStream3ivATIPROC glNormalStream3ivATI = NULL;
+glNormalStream3fATIPROC glNormalStream3fATI = NULL;
+glNormalStream3fvATIPROC glNormalStream3fvATI = NULL;
+glNormalStream3dATIPROC glNormalStream3dATI = NULL;
+glNormalStream3dvATIPROC glNormalStream3dvATI = NULL;
+#endif /* GL_ATI_vertex_streams */
+
+/* ATI_vertex_array_object */
+
+#ifdef GL_ATI_vertex_array_object
+glNewObjectBufferATIPROC glNewObjectBufferATI = NULL;
+glIsObjectBufferATIPROC glIsObjectBufferATI = NULL;
+glUpdateObjectBufferATIPROC glUpdateObjectBufferATI = NULL;
+glGetObjectBufferfvATIPROC glGetObjectBufferfvATI = NULL;
+glGetObjectBufferivATIPROC glGetObjectBufferivATI = NULL;
+glFreeObjectBufferATIPROC glFreeObjectBufferATI = NULL;
+glArrayObjectATIPROC glArrayObjectATI = NULL;
+glGetArrayObjectfvATIPROC glGetArrayObjectfvATI = NULL;
+glGetArrayObjectivATIPROC glGetArrayObjectivATI = NULL;
+glVariantArrayObjectATIPROC glVariantArrayObjectATI = NULL;
+glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI = NULL;
+glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI = NULL;
+#endif /* GL_ATI_vertex_array_object */
+
+/* NV_occlusion_query */
+
+#ifdef GL_NV_occlusion_query
+glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV = NULL;
+glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV = NULL;
+glIsOcclusionQueryNVPROC glIsOcclusionQueryNV = NULL;
+glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV = NULL;
+glEndOcclusionQueryNVPROC glEndOcclusionQueryNV = NULL;
+glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV = NULL;
+glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV = NULL;
+#endif /* GL_NV_occlusion_query */
+
+/* NV_point_sprite */
+
+#ifdef GL_NV_point_sprite
+glPointParameteriNVPROC glPointParameteriNV = NULL;
+glPointParameterivNVPROC glPointParameterivNV = NULL;
+#endif /* GL_NV_point_sprite */
+
+/* ARB_window_pos */
+
+#ifdef GL_ARB_window_pos
+glWindowPos2dARBPROC glWindowPos2dARB = NULL;
+glWindowPos2fARBPROC glWindowPos2fARB = NULL;
+glWindowPos2iARBPROC glWindowPos2iARB = NULL;
+glWindowPos2sARBPROC glWindowPos2sARB = NULL;
+glWindowPos2dvARBPROC glWindowPos2dvARB = NULL;
+glWindowPos2fvARBPROC glWindowPos2fvARB = NULL;
+glWindowPos2ivARBPROC glWindowPos2ivARB = NULL;
+glWindowPos2svARBPROC glWindowPos2svARB = NULL;
+glWindowPos3dARBPROC glWindowPos3dARB = NULL;
+glWindowPos3fARBPROC glWindowPos3fARB = NULL;
+glWindowPos3iARBPROC glWindowPos3iARB = NULL;
+glWindowPos3sARBPROC glWindowPos3sARB = NULL;
+glWindowPos3dvARBPROC glWindowPos3dvARB = NULL;
+glWindowPos3fvARBPROC glWindowPos3fvARB = NULL;
+glWindowPos3ivARBPROC glWindowPos3ivARB = NULL;
+glWindowPos3svARBPROC glWindowPos3svARB = NULL;
+#endif /* GL_ARB_window_pos */
+
+/* EXT_draw_range_elements */
+
+#ifdef GL_EXT_draw_range_elements
+glDrawRangeElementsEXTPROC glDrawRangeElementsEXT = NULL;
+#endif /* GL_EXT_draw_range_elements  */
+
+/* EXT_stencil_two_side */
+
+#ifdef GL_EXT_stencil_two_side
+glActiveStencilFaceEXTPROC glActiveStencilFaceEXT = NULL;
+#endif /* GL_EXT_stencil_two_side */
+
+/* ARB_vertex_program */
+
+#ifdef GL_ARB_vertex_program
+glVertexAttrib1sARBPROC glVertexAttrib1sARB = NULL;
+glVertexAttrib1fARBPROC glVertexAttrib1fARB = NULL;
+glVertexAttrib1dARBPROC glVertexAttrib1dARB = NULL;
+glVertexAttrib2sARBPROC glVertexAttrib2sARB = NULL;
+glVertexAttrib2fARBPROC glVertexAttrib2fARB = NULL;
+glVertexAttrib2dARBPROC glVertexAttrib2dARB = NULL;
+glVertexAttrib3sARBPROC glVertexAttrib3sARB = NULL;
+glVertexAttrib3fARBPROC glVertexAttrib3fARB = NULL;
+glVertexAttrib3dARBPROC glVertexAttrib3dARB = NULL;
+glVertexAttrib4sARBPROC glVertexAttrib4sARB = NULL;
+glVertexAttrib4fARBPROC glVertexAttrib4fARB = NULL;
+glVertexAttrib4dARBPROC glVertexAttrib4dARB = NULL;
+glVertexAttrib4NubARBPROC glVertexAttrib4NubARB = NULL;
+glVertexAttrib1svARBPROC glVertexAttrib1svARB = NULL;
+glVertexAttrib1fvARBPROC glVertexAttrib1fvARB = NULL;
+glVertexAttrib1dvARBPROC glVertexAttrib1dvARB = NULL;
+glVertexAttrib2svARBPROC glVertexAttrib2svARB = NULL;
+glVertexAttrib2fvARBPROC glVertexAttrib2fvARB = NULL;
+glVertexAttrib2dvARBPROC glVertexAttrib2dvARB = NULL;
+glVertexAttrib3svARBPROC glVertexAttrib3svARB = NULL;
+glVertexAttrib3fvARBPROC glVertexAttrib3fvARB = NULL;
+glVertexAttrib3dvARBPROC glVertexAttrib3dvARB = NULL;
+glVertexAttrib4bvARBPROC glVertexAttrib4bvARB = NULL;
+glVertexAttrib4svARBPROC glVertexAttrib4svARB = NULL;
+glVertexAttrib4ivARBPROC glVertexAttrib4ivARB = NULL;
+glVertexAttrib4ubvARBPROC glVertexAttrib4ubvARB = NULL;
+glVertexAttrib4usvARBPROC glVertexAttrib4usvARB = NULL;
+glVertexAttrib4uivARBPROC glVertexAttrib4uivARB = NULL;
+glVertexAttrib4fvARBPROC glVertexAttrib4fvARB = NULL;
+glVertexAttrib4dvARBPROC glVertexAttrib4dvARB = NULL;
+glVertexAttrib4NbvARBPROC glVertexAttrib4NbvARB = NULL;
+glVertexAttrib4NsvARBPROC glVertexAttrib4NsvARB = NULL;
+glVertexAttrib4NivARBPROC glVertexAttrib4NivARB = NULL;
+glVertexAttrib4NubvARBPROC glVertexAttrib4NubvARB = NULL;
+glVertexAttrib4NusvARBPROC glVertexAttrib4NusvARB = NULL;
+glVertexAttrib4NuivARBPROC glVertexAttrib4NuivARB = NULL;
+glVertexAttribPointerARBPROC glVertexAttribPointerARB = NULL;
+glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB = NULL;
+glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = NULL;
+glProgramStringARBPROC glProgramStringARB = NULL;
+glBindProgramARBPROC glBindProgramARB = NULL;
+glDeleteProgramsARBPROC glDeleteProgramsARB = NULL;
+glGenProgramsARBPROC glGenProgramsARB = NULL;
+glProgramEnvParameter4dARBPROC glProgramEnvParameter4dARB = NULL;
+glProgramEnvParameter4dvARBPROC glProgramEnvParameter4dvARB = NULL;
+glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB = NULL;
+glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB = NULL;
+glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB = NULL;
+glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB = NULL;
+glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB = NULL;
+glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = NULL;
+glGetProgramEnvParameterdvARBPROC glGetProgramEnvParameterdvARB = NULL;
+glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB = NULL;
+glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB = NULL;
+glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB = NULL;
+glGetProgramivARBPROC glGetProgramivARB = NULL;
+glGetProgramStringARBPROC glGetProgramStringARB = NULL;
+glGetVertexAttribdvARBPROC glGetVertexAttribdvARB = NULL;
+glGetVertexAttribfvARBPROC glGetVertexAttribfvARB = NULL;
+glGetVertexAttribivARBPROC glGetVertexAttribivARB = NULL;
+glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB = NULL;
+glIsProgramARBPROC glIsProgramARB = NULL;
+#endif /* GL_ARB_vertex_program */
+
+/* EXT_cull_vertex */
+
+#ifdef GL_EXT_cull_vertex
+glCullParameterfvEXTPROC glCullParameterfvEXT = NULL;
+glCullParameterdvEXTPROC glCullParameterdvEXT = NULL;
+#endif /* GL_EXT_cull_vertex */
+
+#ifdef GL_EXT_blend_function_sepatate
+glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT = NULL;
+glBlendFuncSeparateINGRPROC glBlendFuncSeparateINGR = NULL;
+#endif /* GL_EXT_blend_func_separate */
+
+#ifdef _WIN32
+#ifdef GL_VERSION_1_4
+/*#ifndef GL_VERSION_1_2
+glBlendColorPROC glBlendColor = NULL;
+glBlendEquationPROC glBlendEquation = NULL;
+#endif *//* GL_VERSION_1_2 */
+glFogCoordfPROC glFogCoordf = NULL;
+glFogCoordfvPROC glFogCoordfv = NULL;
+glFogCoorddPROC glFogCoordd = NULL;
+glFogCoorddvPROC glFogCoorddv = NULL;
+glFogCoordPointerPROC glFogCoordPointer = NULL;
+glMultiDrawArraysPROC glMultiDrawArrays = NULL;
+glMultiDrawElementsPROC glMultiDrawElements = NULL;
+glPointParameterfPROC glPointParameterf = NULL;
+glPointParameterfvPROC glPointParameterfv = NULL;
+glSecondaryColor3bPROC glSecondaryColor3b = NULL;
+glSecondaryColor3bvPROC glSecondaryColor3bv = NULL;
+glSecondaryColor3dPROC glSecondaryColor3d = NULL;
+glSecondaryColor3dvPROC glSecondaryColor3dv = NULL;
+glSecondaryColor3fPROC glSecondaryColor3f = NULL;
+glSecondaryColor3fvPROC glSecondaryColor3fv = NULL;
+glSecondaryColor3iPROC glSecondaryColor3i = NULL;
+glSecondaryColor3ivPROC glSecondaryColor3iv = NULL;
+glSecondaryColor3sPROC glSecondaryColor3s = NULL;
+glSecondaryColor3svPROC glSecondaryColor3sv = NULL;
+glSecondaryColor3ubPROC glSecondaryColor3ub = NULL;
+glSecondaryColor3ubvPROC glSecondaryColor3ubv = NULL;
+glSecondaryColor3uiPROC glSecondaryColor3ui = NULL;
+glSecondaryColor3uivPROC glSecondaryColor3uiv = NULL;
+glSecondaryColor3usPROC glSecondaryColor3us = NULL;
+glSecondaryColor3usvPROC glSecondaryColor3usv = NULL;
+glSecondaryColorPointerPROC glSecondaryColorPointer = NULL;
+glBlendFuncSeparatePROC glBlendFuncSeparate = NULL;
+glWindowPos2dPROC glWindowPos2d = NULL;
+glWindowPos2fPROC glWindowPos2f = NULL;
+glWindowPos2iPROC glWindowPos2i = NULL;
+glWindowPos2sPROC glWindowPos2s = NULL;
+glWindowPos2dvPROC glWindowPos2dv = NULL;
+glWindowPos2fvPROC glWindowPos2fv = NULL;
+glWindowPos2ivPROC glWindowPos2iv = NULL;
+glWindowPos2svPROC glWindowPos2sv = NULL;
+glWindowPos3dPROC glWindowPos3d = NULL;
+glWindowPos3fPROC glWindowPos3f = NULL;
+glWindowPos3iPROC glWindowPos3i = NULL;
+glWindowPos3sPROC glWindowPos3s = NULL;
+glWindowPos3dvPROC glWindowPos3dv = NULL;
+glWindowPos3fvPROC glWindowPos3fv = NULL;
+glWindowPos3ivPROC glWindowPos3iv = NULL;
+glWindowPos3svPROC glWindowPos3sv = NULL;
+#endif /* GL_VERSION_1_4 */
+#endif /* WIN32 */
+
+#ifdef GL_EXT_blend_func_separate
+glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT = NULL;
+#endif /* GL_EXT_blend_func_separate */
+
+
+#ifdef GL_NV_element_array
+glElementPointerNVPROC glElementPointerNV = NULL;
+glDrawElementArrayNVPROC glDrawElementArrayNV = NULL;
+glDrawRangeElementArrayNVPROC glDrawRangeElementArrayNV = NULL;
+glMultiDrawElementArrayNVPROC glMultiDrawElementArrayNV = NULL;
+glMultiDrawRangeElementArrayNVPROC glMultiDrawRangeElementArrayNV = NULL;
+#endif /* GL_NV_element_array */
+
+#ifdef GL_NV_fragment_program
+glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV = NULL;
+glProgramNamedParameter4dNVPROC glProgramNamedParameter4dNV = NULL;
+glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV = NULL;
+glProgramNamedParameter4dvNVPROC glProgramNamedParameter4dvNV = NULL;
+glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV = NULL;
+glGetProgramNamedParameterdvNVPROC glGetProgramNamedParameterdvNV = NULL;
+#ifndef GL_ARB_vertex_program
+glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB = NULL;
+glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB = NULL;
+glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB = NULL;
+glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = NULL;
+glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB = NULL;
+glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB = NULL;
+#endif /* GL_ARB_vertex_program */
+#endif /* GL_NV_fragment_program */
+
+
+#ifdef GL_NV_primitive_restart
+glPrimitiveRestartNVPROC glPrimitiveRestartNV = NULL;
+glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV = NULL;
+#endif /* GL_NV_primitive_restart */
+
+// added -ec
+#ifdef GL_ATI_draw_buffers
+PFNGLDRAWBUFFERS glDrawBuffersATI;
+#endif
+
+static int extgl_error = 0;
+
+struct ExtensionTypes extgl_Extensions;
+
+struct ExtensionTypes SupportedExtensions; /* deprecated, please do not use */
+
+
+/* getProcAddress */
+
+void *extgl_GetProcAddress(const char *name)
+{
+#ifdef _WIN32
+    void *t = wglGetProcAddress(name);
+    if (t == NULL)
+    {
+        extgl_error = 1;  
+    }
+    return t;
+#else
+    void *t = (void*)glXGetProcAddressARB((GLubyte *)name);
+    if (t == NULL)
+    {
+        extgl_error = 1;
+    }
+    return t;
+#endif
+}
+
+/*-----------------------------------------------------*/
+/* WGL stuff */
+/*-----------------------------------------------------*/
+
+#ifdef _WIN32
+
+/** returns true if the extention is available */
+int QueryWGLExtension(const char *name)
+{
+    const GLubyte *extensions;
+    const GLubyte *start;
+    GLubyte *where, *terminator;
+
+    /* Extension names should not have spaces. */
+    where = (GLubyte *) strchr(name, ' ');
+    if (where || *name == '\0')
+        return 0;
+    if (wglGetExtensionsStringARB == NULL)
+        if (wglGetExtensionsStringEXT == NULL)
+            return 0;
+        else
+            extensions = (GLubyte*)wglGetExtensionsStringEXT();
+    else
+        extensions = (GLubyte*)wglGetExtensionsStringARB(wglGetCurrentDC());
+    /* It takes a bit of care to be fool-proof about parsing the
+         OpenGL extensions string. Don't be fooled by sub-strings,
+        etc. */
+    start = extensions;
+    for (;;) 
+    {
+        where = (GLubyte *) strstr((const char *) start, name);
+        if (!where)
+            break;
+        terminator = where + strlen(name);
+        if (where == start || *(where - 1) == ' ')
+            if (*terminator == ' ' || *terminator == '\0')
+                return 1;
+        start = terminator;
+    }
+    return 0;
+}
+
+void extgl_InitWGLARBBufferRegion()
+{
+#ifdef WGL_ARB_buffer_region    
+    if (!extgl_Extensions.wgl.ARB_buffer_region)
+        return;
+    wglCreateBufferRegionARB = (wglCreateBufferRegionARBPROC) extgl_GetProcAddress("wglCreateBufferRegionARB");
+    wglDeleteBufferRegionARB = (wglDeleteBufferRegionARBPROC) extgl_GetProcAddress("wglDeleteBufferRegionARB");
+    wglSaveBufferRegionARB = (wglSaveBufferRegionARBPROC) extgl_GetProcAddress("wglSaveBufferRegionARB");
+    wglRestoreBufferRegionARB = (wglRestoreBufferRegionARBPROC) extgl_GetProcAddress("wglRestoreBufferRegionARB");
+#endif
+}
+
+void extgl_InitWGLARBPbuffer()
+{
+#ifdef WGL_ARB_pbuffer
+    if (!extgl_Extensions.wgl.ARB_pbuffer)
+        return;
+    wglCreatePbufferARB = (wglCreatePbufferARBPROC) extgl_GetProcAddress("wglCreatePbufferARB");
+    wglGetPbufferDCARB = (wglGetPbufferDCARBPROC) extgl_GetProcAddress("wglGetPbufferDCARB");
+    wglReleasePbufferDCARB = (wglReleasePbufferDCARBPROC) extgl_GetProcAddress("wglReleasePbufferDCARB");
+    wglDestroyPbufferARB = (wglDestroyPbufferARBPROC) extgl_GetProcAddress("wglDestroyPbufferARB");
+    wglQueryPbufferARB = (wglQueryPbufferARBPROC) extgl_GetProcAddress("wglQueryPbufferARB");
+#endif
+}
+
+void extgl_InitWGLARBPixelFormat()
+{
+#ifdef WGL_ARB_pixel_format
+    if (!extgl_Extensions.wgl.ARB_pixel_format)
+        return;
+    wglGetPixelFormatAttribivARB = (wglGetPixelFormatAttribivARBPROC) extgl_GetProcAddress("wglGetPixelFormatAttribivARB");
+    wglGetPixelFormatAttribfvARB = (wglGetPixelFormatAttribfvARBPROC) extgl_GetProcAddress("wglGetPixelFormatAttribfvARB");
+    wglChoosePixelFormatARB = (wglChoosePixelFormatARBPROC) extgl_GetProcAddress("wglChoosePixelFormatARB");
+#endif
+}
+
+void extgl_InitWGLARBRenderTexture()
+{
+#ifdef WGL_ARB_render_texture
+    if (!extgl_Extensions.wgl.ARB_render_texture)
+        return;
+    wglBindTexImageARB = (wglBindTexImageARBPROC) extgl_GetProcAddress("wglBindTexImageARB");
+    wglReleaseTexImageARB = (wglReleaseTexImageARBPROC) extgl_GetProcAddress("wglReleaseTexImageARB");
+    wglSetPbufferAttribARB = (wglSetPbufferAttribARBPROC) extgl_GetProcAddress("wglSetPbufferAttribARB");
+#endif
+}
+
+void extgl_InitWGLEXTSwapControl()
+{
+#ifdef WGL_EXT_swap_control
+    if (!extgl_Extensions.wgl.EXT_swap_control)
+        return;
+    wglSwapIntervalEXT = (wglSwapIntervalEXTPROC) extgl_GetProcAddress("wglSwapIntervalEXT");
+    wglGetSwapIntervalEXT = (wglGetSwapIntervalEXTPROC) extgl_GetProcAddress("wglGetSwapIntervalEXT");
+#endif
+}
+
+void extgl_InitWGLARBMakeCurrentRead()
+{
+#ifdef WGL_ARB_make_current_read
+    if (!extgl_Extensions.wgl.ARB_make_current_read)
+        return;
+    wglMakeContextCurrentARB = (wglMakeContextCurrentARBPROC) extgl_GetProcAddress("wglMakeContextCurrentARB");
+    wglGetCurrentReadDCARB = (wglGetCurrentReadDCARBPROC) extgl_GetProcAddress("wglGetCurrentReadDCARB");
+#endif
+}
+
+void extgl_InitSupportedWGLExtensions()
+{
+    extgl_Extensions.wgl.ARB_buffer_region = QueryWGLExtension("WGL_ARB_buffer_region");
+    extgl_Extensions.wgl.ARB_make_current_read = QueryWGLExtension("WGL_ARB_make_current_read");
+    extgl_Extensions.wgl.ARB_multisample = QueryWGLExtension("WGL_ARB_multisample");
+    extgl_Extensions.wgl.ARB_pbuffer = QueryWGLExtension("WGL_ARB_pbuffer");
+    extgl_Extensions.wgl.ARB_pixel_format = QueryWGLExtension("WGL_ARB_pixel_format");
+    extgl_Extensions.wgl.ARB_render_texture = QueryWGLExtension("WGL_ARB_render_texture");
+    extgl_Extensions.wgl.EXT_swap_control = QueryWGLExtension("WGL_EXT_swap_control");
+    extgl_Extensions.wgl.NV_render_depth_texture = QueryWGLExtension("WGL_NV_render_depth_texture");
+    extgl_Extensions.wgl.NV_render_texture_rectangle = QueryWGLExtension("WGL_NV_render_texture_rectangle");
+    extgl_Extensions.wgl.ATI_pixel_format_float = QueryWGLExtension("WGL_ATI_pixel_format_float"); // added -ec
+}
+
+int extgl_InitializeWGL()
+{
+    extgl_error = 0;
+    wglGetExtensionsStringARB = (wglGetExtensionsStringARBPROC) extgl_GetProcAddress("wglGetExtensionsStringARB");
+    wglGetExtensionsStringEXT = (wglGetExtensionsStringEXTPROC) extgl_GetProcAddress("wglGetExtensionsStringEXT");
+    extgl_Extensions.wgl.ARB_extensions_string = wglGetExtensionsStringARB != NULL;
+    extgl_Extensions.wgl.EXT_extensions_string = wglGetExtensionsStringEXT != NULL;
+    extgl_error = 0;
+
+    extgl_InitSupportedWGLExtensions();
+   
+
+    extgl_InitWGLARBMakeCurrentRead();
+    extgl_InitWGLEXTSwapControl();
+    extgl_InitWGLARBRenderTexture();
+    extgl_InitWGLARBPixelFormat();
+    extgl_InitWGLARBPbuffer();
+    extgl_InitWGLARBBufferRegion();
+    
+    return extgl_error;
+}
+
+#endif /* WIN32 */
+
+/*-----------------------------------------------------*/
+/* WGL stuff END*/
+/*-----------------------------------------------------*/
+
+/** returns true if the extention is available */
+int QueryExtension(const char *name)
+{
+    const GLubyte *extensions;
+    const GLubyte *start;
+    GLubyte *where, *terminator;
+
+    /* Extension names should not have spaces. */
+    where = (GLubyte *) strchr(name, ' ');
+    if (where || *name == '\0')
+        return 0;
+    extensions = glGetString(GL_EXTENSIONS);
+    /* It takes a bit of care to be fool-proof about parsing the
+         OpenGL extensions string. Don't be fooled by sub-strings,
+        etc. */
+    start = extensions;
+    for (;;) 
+    {
+        where = (GLubyte *) strstr((const char *) start, name);
+        if (!where)
+            break;
+        terminator = where + strlen(name);
+        if (where == start || *(where - 1) == ' ')
+            if (*terminator == ' ' || *terminator == '\0')
+                return 1;
+        start = terminator;
+    }
+    return 0;
+}
+
+// added -ec
+/* ATI_draw_buffers */
+void extgl_InitATIDrawBuffers()
+{
+#ifdef GL_ATI_draw_buffers
+    if (!extgl_Extensions.ATI_draw_buffers)
+        return;
+    glDrawBuffersATI = (PFNGLDRAWBUFFERS) extgl_GetProcAddress("glDrawBuffersATI");
+#endif
+}
+
+void extgl_InitARBFragmentProgram()
+{
+#ifdef GL_ARB_fragment_program
+    if (!extgl_Extensions.ARB_fragment_program)
+        return;
+    glProgramStringARB = (glProgramStringARBPROC) extgl_GetProcAddress("glProgramStringARB");
+    glBindProgramARB = (glBindProgramARBPROC) extgl_GetProcAddress("glBindProgramARB");
+    glDeleteProgramsARB = (glDeleteProgramsARBPROC) extgl_GetProcAddress("glDeleteProgramsARB");
+    glGenProgramsARB = (glGenProgramsARBPROC) extgl_GetProcAddress("glGenProgramsARB");
+    glProgramEnvParameter4dARB = (glProgramEnvParameter4dARBPROC) extgl_GetProcAddress("glProgramEnvParameter4dARB");
+    glProgramEnvParameter4dvARB = (glProgramEnvParameter4dvARBPROC) extgl_GetProcAddress("glProgramEnvParameter4dvARB");
+    glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fARB");
+    glProgramEnvParameter4fvARB = (glProgramEnvParameter4fvARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fvARB");
+    glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dARB");
+    glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dvARB");
+    glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fARB");
+    glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fvARB");
+    glGetProgramEnvParameterdvARB = (glGetProgramEnvParameterdvARBPROC) extgl_GetProcAddress("glGetProgramEnvParameterdvARB");
+    glGetProgramEnvParameterfvARB = (glGetProgramEnvParameterfvARBPROC) extgl_GetProcAddress("glGetProgramEnvParameterfvARB");
+    glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterdvARB");
+    glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvARB");
+    glGetProgramivARB = (glGetProgramivARBPROC) extgl_GetProcAddress("glGetProgramivARB");
+    glGetProgramStringARB = (glGetProgramStringARBPROC) extgl_GetProcAddress("glGetProgramStringARB");
+    glIsProgramARB = (glIsProgramARBPROC) extgl_GetProcAddress("glIsProgramARB");
+#endif
+}
+
+void extgl_InitNVPrimitiveRestart()
+{
+#ifdef GL_NV_primitive_restart
+    if (!extgl_Extensions.NV_primitive_restart)
+        return;
+    glPrimitiveRestartNV = (glPrimitiveRestartNVPROC) extgl_GetProcAddress("glPrimitiveRestartNV");
+    glPrimitiveRestartIndexNV = (glPrimitiveRestartIndexNVPROC) extgl_GetProcAddress("glPrimitiveRestartIndexNV");
+#endif /* GL_NV_primitive_restart */
+}
+
+void extgl_InitNVFragmentProgram()
+{
+#ifdef GL_NV_fragment_program
+    if (!extgl_Extensions.NV_fragment_program)
+        return;
+    glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fNV");
+    glProgramNamedParameter4dNV = (glProgramNamedParameter4dNVPROC) extgl_GetProcAddress("glProgramNamedParameter4dNV");
+    glProgramNamedParameter4fvNV = (glProgramNamedParameter4fvNVPROC) extgl_GetProcAddress("glProgramNamedParameter4fvNV");
+    glProgramNamedParameter4dvNV = (glProgramNamedParameter4dvNVPROC) extgl_GetProcAddress("glProgramNamedParameter4dvNV");
+    glGetProgramNamedParameterfvNV = (glGetProgramNamedParameterfvNVPROC) extgl_GetProcAddress("glGetProgramNamedParameterfvNV");
+    glGetProgramNamedParameterdvNV = (glGetProgramNamedParameterdvNVPROC) extgl_GetProcAddress("glGetProgramNamedParameterdvNV");
+#ifndef GL_ARB_vertex_program
+    glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dARB");
+    glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dvARB");
+    glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fARB");
+    glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fvARB");
+    glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterdvARB");
+    glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvARB");
+#endif /* GL_ARB_vertex_program */
+#endif /* GL_NV_fragment_program */
+}
+
+void extgl_InitNVElementArray()
+{
+#ifdef GL_NV_element_array
+    if (!extgl_Extensions.NV_element_array)
+        return;
+    glElementPointerNV = (glElementPointerNVPROC) extgl_GetProcAddress("glElementPointerNV");
+    glDrawElementArrayNV = (glDrawElementArrayNVPROC) extgl_GetProcAddress("glDrawElementArrayNV");
+    glDrawRangeElementArrayNV = (glDrawRangeElementArrayNVPROC) extgl_GetProcAddress("glDrawRangeElementArrayNV");
+    glMultiDrawElementArrayNV = (glMultiDrawElementArrayNVPROC) extgl_GetProcAddress("glMultiDrawElementArrayNV");
+    glMultiDrawRangeElementArrayNV = (glMultiDrawRangeElementArrayNVPROC) extgl_GetProcAddress("glMultiDrawRangeElementArrayNV");
+#endif
+}
+
+
+void extgl_InitEXTBlendFuncSeparate()
+{
+#ifdef GL_EXT_blend_func_separate
+    if (!extgl_Extensions.EXT_blend_func_separate)
+        return;
+    glBlendFuncSeparateEXT = (glBlendFuncSeparateEXTPROC) extgl_GetProcAddress("glBlendFuncSeparateEXT");
+#endif
+}
+
+void extgl_InitEXTCullVertex()
+{
+#ifdef GL_EXT_cull_vertex
+    if (!extgl_Extensions.EXT_cull_vertex)
+        return;
+    glCullParameterfvEXT = (glCullParameterfvEXTPROC) extgl_GetProcAddress("glCullParameterfvEXT");
+    glCullParameterdvEXT = (glCullParameterdvEXTPROC) extgl_GetProcAddress("glCullParameterdvEXT");
+#endif
+}
+
+void extgl_InitARBVertexProgram()
+{
+#ifdef GL_ARB_vertex_program
+    if (!extgl_Extensions.ARB_vertex_program)
+        return;
+    glVertexAttrib1sARB = (glVertexAttrib1sARBPROC) extgl_GetProcAddress("glVertexAttrib1sARB");
+    glVertexAttrib1fARB = (glVertexAttrib1fARBPROC) extgl_GetProcAddress("glVertexAttrib1fARB");
+    glVertexAttrib1dARB = (glVertexAttrib1dARBPROC) extgl_GetProcAddress("glVertexAttrib1dARB");
+    glVertexAttrib2sARB = (glVertexAttrib2sARBPROC) extgl_GetProcAddress("glVertexAttrib2sARB");
+    glVertexAttrib2fARB = (glVertexAttrib2fARBPROC) extgl_GetProcAddress("glVertexAttrib2fARB");
+    glVertexAttrib2dARB = (glVertexAttrib2dARBPROC) extgl_GetProcAddress("glVertexAttrib2dARB");
+    glVertexAttrib3sARB = (glVertexAttrib3sARBPROC) extgl_GetProcAddress("glVertexAttrib3sARB");
+    glVertexAttrib3fARB = (glVertexAttrib3fARBPROC) extgl_GetProcAddress("glVertexAttrib3fARB");
+    glVertexAttrib3dARB = (glVertexAttrib3dARBPROC) extgl_GetProcAddress("glVertexAttrib3dARB");
+    glVertexAttrib4sARB = (glVertexAttrib4sARBPROC) extgl_GetProcAddress("glVertexAttrib4sARB");
+    glVertexAttrib4fARB = (glVertexAttrib4fARBPROC) extgl_GetProcAddress("glVertexAttrib4fARB");
+    glVertexAttrib4dARB = (glVertexAttrib4dARBPROC) extgl_GetProcAddress("glVertexAttrib4dARB");
+    glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC) extgl_GetProcAddress("glVertexAttrib4NubARB");
+    glVertexAttrib1svARB = (glVertexAttrib1svARBPROC) extgl_GetProcAddress("glVertexAttrib1svARB");
+    glVertexAttrib1fvARB = (glVertexAttrib1fvARBPROC) extgl_GetProcAddress("glVertexAttrib1fvARB");
+    glVertexAttrib1dvARB = (glVertexAttrib1dvARBPROC) extgl_GetProcAddress("glVertexAttrib1dvARB");
+    glVertexAttrib2svARB = (glVertexAttrib2svARBPROC) extgl_GetProcAddress("glVertexAttrib2svARB");
+    glVertexAttrib2fvARB = (glVertexAttrib2fvARBPROC) extgl_GetProcAddress("glVertexAttrib2fvARB");
+    glVertexAttrib2dvARB = (glVertexAttrib2dvARBPROC) extgl_GetProcAddress("glVertexAttrib2dvARB");
+    glVertexAttrib3svARB = (glVertexAttrib3svARBPROC) extgl_GetProcAddress("glVertexAttrib3svARB");
+    glVertexAttrib3fvARB = (glVertexAttrib3fvARBPROC) extgl_GetProcAddress("glVertexAttrib3fvARB");
+    glVertexAttrib3dvARB = (glVertexAttrib3dvARBPROC) extgl_GetProcAddress("glVertexAttrib3dvARB");
+    glVertexAttrib4bvARB = (glVertexAttrib4bvARBPROC) extgl_GetProcAddress("glVertexAttrib4bvARB");
+    glVertexAttrib4svARB = (glVertexAttrib4svARBPROC) extgl_GetProcAddress("glVertexAttrib4svARB");
+    glVertexAttrib4ivARB = (glVertexAttrib4ivARBPROC) extgl_GetProcAddress("glVertexAttrib4ivARB");
+    glVertexAttrib4ubvARB = (glVertexAttrib4ubvARBPROC) extgl_GetProcAddress("glVertexAttrib4ubvARB");
+    glVertexAttrib4usvARB = (glVertexAttrib4usvARBPROC) extgl_GetProcAddress("glVertexAttrib4usvARB");
+    glVertexAttrib4uivARB = (glVertexAttrib4uivARBPROC) extgl_GetProcAddress("glVertexAttrib4uivARB");
+    glVertexAttrib4fvARB = (glVertexAttrib4fvARBPROC) extgl_GetProcAddress("glVertexAttrib4fvARB");
+    glVertexAttrib4dvARB = (glVertexAttrib4dvARBPROC) extgl_GetProcAddress("glVertexAttrib4dvARB");
+    glVertexAttrib4NbvARB = (glVertexAttrib4NbvARBPROC) extgl_GetProcAddress("glVertexAttrib4NbvARB");
+    glVertexAttrib4NsvARB = (glVertexAttrib4NsvARBPROC) extgl_GetProcAddress("glVertexAttrib4NsvARB");
+    glVertexAttrib4NivARB = (glVertexAttrib4NivARBPROC) extgl_GetProcAddress("glVertexAttrib4NivARB");
+    glVertexAttrib4NubvARB = (glVertexAttrib4NubvARBPROC) extgl_GetProcAddress("glVertexAttrib4NubvARB");
+    glVertexAttrib4NusvARB = (glVertexAttrib4NusvARBPROC) extgl_GetProcAddress("glVertexAttrib4NusvARB");
+    glVertexAttrib4NuivARB = (glVertexAttrib4NuivARBPROC) extgl_GetProcAddress("glVertexAttrib4NuivARB");
+    glVertexAttribPointerARB = (glVertexAttribPointerARBPROC) extgl_GetProcAddress("glVertexAttribPointerARB");
+    glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC) extgl_GetProcAddress("glEnableVertexAttribArrayARB");
+    glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC) extgl_GetProcAddress("glDisableVertexAttribArrayARB");
+    glProgramStringARB = (glProgramStringARBPROC) extgl_GetProcAddress("glProgramStringARB");
+    glBindProgramARB = (glBindProgramARBPROC) extgl_GetProcAddress("glBindProgramARB");
+    glDeleteProgramsARB = (glDeleteProgramsARBPROC) extgl_GetProcAddress("glDeleteProgramsARB");
+    glGenProgramsARB = (glGenProgramsARBPROC) extgl_GetProcAddress("glGenProgramsARB");
+    glProgramEnvParameter4dARB = (glProgramEnvParameter4dARBPROC) extgl_GetProcAddress("glProgramEnvParameter4dARB");
+    glProgramEnvParameter4dvARB = (glProgramEnvParameter4dvARBPROC) extgl_GetProcAddress("glProgramEnvParameter4dvARB");
+    glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fARB");
+    glProgramEnvParameter4fvARB = (glProgramEnvParameter4fvARBPROC) extgl_GetProcAddress("glProgramEnvParameter4fvARB");
+    glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dARB");
+    glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4dvARB");
+    glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fARB");
+    glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC) extgl_GetProcAddress("glProgramLocalParameter4fvARB");
+    glGetProgramEnvParameterdvARB = (glGetProgramEnvParameterdvARBPROC) extgl_GetProcAddress("glGetProgramEnvParameterdvARB");
+    glGetProgramEnvParameterfvARB = (glGetProgramEnvParameterfvARBPROC) extgl_GetProcAddress("glGetProgramEnvParameterfvARB");
+    glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterdvARB");
+    glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC) extgl_GetProcAddress("glGetProgramLocalParameterfvARB");
+    glGetProgramivARB = (glGetProgramivARBPROC) extgl_GetProcAddress("glGetProgramivARB");
+    glGetProgramStringARB = (glGetProgramStringARBPROC) extgl_GetProcAddress("glGetProgramStringARB");
+    glGetVertexAttribdvARB = (glGetVertexAttribdvARBPROC) extgl_GetProcAddress("glGetVertexAttribdvARB");
+    glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC) extgl_GetProcAddress("glGetVertexAttribfvARB");
+    glGetVertexAttribivARB = (glGetVertexAttribivARBPROC) extgl_GetProcAddress("glGetVertexAttribivARB");
+    glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC) extgl_GetProcAddress("glGetVertexAttribPointervARB");
+    glIsProgramARB = (glIsProgramARBPROC) extgl_GetProcAddress("glIsProgramARB");
+#endif
+}
+
+void extgl_InitEXTStencilTwoSide()
+{
+#ifdef GL_EXT_stencil_two_side
+    if (!extgl_Extensions.EXT_stencil_two_side)
+        return;
+    glActiveStencilFaceEXT = (glActiveStencilFaceEXTPROC) extgl_GetProcAddress("glActiveStencilFaceEXT");
+#endif
+}
+
+void extgl_InitARBWindowPos()
+{
+#ifdef GL_ARB_window_pos
+    if (!extgl_Extensions.ARB_window_pos)
+        return;
+    glWindowPos2dARB = (glWindowPos2dARBPROC) extgl_GetProcAddress("glWindowPos2dARB");
+    glWindowPos2fARB = (glWindowPos2fARBPROC) extgl_GetProcAddress("glWindowPos2fARB");
+    glWindowPos2iARB = (glWindowPos2iARBPROC) extgl_GetProcAddress("glWindowPos2iARB");
+    glWindowPos2sARB = (glWindowPos2sARBPROC) extgl_GetProcAddress("glWindowPos2sARB");
+    glWindowPos2dvARB = (glWindowPos2dvARBPROC) extgl_GetProcAddress("glWindowPos2dvARB");
+    glWindowPos2fvARB = (glWindowPos2fvARBPROC) extgl_GetProcAddress("glWindowPos2fvARB");
+    glWindowPos2ivARB = (glWindowPos2ivARBPROC) extgl_GetProcAddress("glWindowPos2ivARB");
+    glWindowPos2svARB = (glWindowPos2svARBPROC) extgl_GetProcAddress("glWindowPos2svARB");
+    glWindowPos3dARB = (glWindowPos3dARBPROC) extgl_GetProcAddress("glWindowPos3dARB");
+    glWindowPos3fARB = (glWindowPos3fARBPROC) extgl_GetProcAddress("glWindowPos3fARB");
+    glWindowPos3iARB = (glWindowPos3iARBPROC) extgl_GetProcAddress("glWindowPos3iARB");
+    glWindowPos3sARB = (glWindowPos3sARBPROC) extgl_GetProcAddress("glWindowPos3sARB");
+    glWindowPos3dvARB = (glWindowPos3dvARBPROC) extgl_GetProcAddress("glWindowPos3dvARB");
+    glWindowPos3fvARB = (glWindowPos3fvARBPROC) extgl_GetProcAddress("glWindowPos3fvARB");
+    glWindowPos3ivARB = (glWindowPos3ivARBPROC) extgl_GetProcAddress("glWindowPos3ivARB");
+    glWindowPos3svARB = (glWindowPos3svARBPROC) extgl_GetProcAddress("glWindowPos3svARB");
+#endif 
+}
+
+void extgl_InitARBTextureCompression()
+{
+#ifdef GL_ARB_texture_compression
+    if (!extgl_Extensions.ARB_texture_compression)
+        return;
+    glCompressedTexImage3DARB = (glCompressedTexImage3DARBPROC) extgl_GetProcAddress("glCompressedTexImage3DARB");
+    glCompressedTexImage2DARB = (glCompressedTexImage2DARBPROC) extgl_GetProcAddress("glCompressedTexImage2DARB");
+    glCompressedTexImage1DARB = (glCompressedTexImage1DARBPROC) extgl_GetProcAddress("glCompressedTexImage1DARB");
+    glCompressedTexSubImage3DARB = (glCompressedTexSubImage3DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage3DARB");
+    glCompressedTexSubImage2DARB = (glCompressedTexSubImage2DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage2DARB");
+    glCompressedTexSubImage1DARB = (glCompressedTexSubImage1DARBPROC) extgl_GetProcAddress("glCompressedTexSubImage1DARB");
+    glGetCompressedTexImageARB = (glGetCompressedTexImageARBPROC) extgl_GetProcAddress("glGetCompressedTexImageARB");
+#endif
+}
+
+void extgl_InitNVPointSprite()
+{
+#ifdef GL_NV_point_sprite
+    if (!extgl_Extensions.NV_point_sprite)
+        return;
+    glPointParameteriNV = (glPointParameteriNVPROC) extgl_GetProcAddress("glPointParameteriNV");
+    glPointParameterivNV = (glPointParameterivNVPROC) extgl_GetProcAddress("glPointParameterivNV");
+#endif
+}
+
+void extgl_InitNVOcclusionQuery()
+{
+#ifdef GL_NV_occlusion_query
+    if (!extgl_Extensions.NV_occlusion_query)
+        return;
+    glGenOcclusionQueriesNV = (glGenOcclusionQueriesNVPROC) extgl_GetProcAddress("glGenOcclusionQueriesNV");
+    glDeleteOcclusionQueriesNV = (glDeleteOcclusionQueriesNVPROC) extgl_GetProcAddress("glDeleteOcclusionQueriesNV");
+    glIsOcclusionQueryNV = (glIsOcclusionQueryNVPROC) extgl_GetProcAddress("glIsOcclusionQueryNV");
+    glBeginOcclusionQueryNV = (glBeginOcclusionQueryNVPROC) extgl_GetProcAddress("glBeginOcclusionQueryNV");
+    glEndOcclusionQueryNV = (glEndOcclusionQueryNVPROC) extgl_GetProcAddress("glEndOcclusionQueryNV");
+    glGetOcclusionQueryivNV = (glGetOcclusionQueryivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryivNV");
+    glGetOcclusionQueryuivNV = (glGetOcclusionQueryuivNVPROC) extgl_GetProcAddress("glGetOcclusionQueryuivNV");
+#endif
+}
+
+void extgl_InitATIVertexArrayObject()
+{
+#ifdef GL_ATI_vertex_array_object
+    if (!extgl_Extensions.ATI_vertex_array_object)
+        return;
+    glNewObjectBufferATI = (glNewObjectBufferATIPROC) extgl_GetProcAddress("glNewObjectBufferATI");
+    glIsObjectBufferATI = (glIsObjectBufferATIPROC) extgl_GetProcAddress("glIsObjectBufferATI");
+    glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC) extgl_GetProcAddress("glUpdateObjectBufferATI");
+    glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC) extgl_GetProcAddress("glGetObjectBufferfvATI");
+    glGetObjectBufferivATI = (glGetObjectBufferivATIPROC) extgl_GetProcAddress("glGetObjectBufferivATI");
+    glFreeObjectBufferATI = (glFreeObjectBufferATIPROC) extgl_GetProcAddress("glFreeObjectBufferATI");
+    glArrayObjectATI = (glArrayObjectATIPROC) extgl_GetProcAddress("glArrayObjectATI");
+    glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC) extgl_GetProcAddress("glGetArrayObjectfvATI");
+    glGetArrayObjectivATI = (glGetArrayObjectivATIPROC) extgl_GetProcAddress("glGetArrayObjectivATI");
+    glVariantArrayObjectATI = (glVariantArrayObjectATIPROC) extgl_GetProcAddress("glVariantArrayObjectATI");
+    glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC) extgl_GetProcAddress("glGetVariantArrayObjectfvATI");
+    glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC) extgl_GetProcAddress("glGetVariantArrayObjectivATI");
+#endif
+}
+
+void extgl_InitATIVertexStreams()
+{
+#ifdef GL_ATI_vertex_streams
+    if (!extgl_Extensions.ATI_vertex_streams)
+        return;
+    glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC) extgl_GetProcAddress("glClientActiveVertexStreamATI");
+    glVertexBlendEnviATI = (glVertexBlendEnviATIPROC) extgl_GetProcAddress("glVertexBlendEnviATI");
+    glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC) extgl_GetProcAddress("glVertexBlendEnvfATI");
+    glVertexStream2sATI = (glVertexStream2sATIPROC) extgl_GetProcAddress("glVertexStream2sATI");
+    glVertexStream2svATI = (glVertexStream2svATIPROC) extgl_GetProcAddress("glVertexStream2svATI");
+    glVertexStream2iATI = (glVertexStream2iATIPROC) extgl_GetProcAddress("glVertexStream2iATI");
+    glVertexStream2ivATI = (glVertexStream2ivATIPROC) extgl_GetProcAddress("glVertexStream2ivATI");
+    glVertexStream2fATI = (glVertexStream2fATIPROC) extgl_GetProcAddress("glVertexStream2fATI");
+    glVertexStream2fvATI = (glVertexStream2fvATIPROC) extgl_GetProcAddress("glVertexStream2fvATI");
+    glVertexStream2dATI = (glVertexStream2dATIPROC) extgl_GetProcAddress("glVertexStream2dATI");
+    glVertexStream2dvATI = (glVertexStream2dvATIPROC) extgl_GetProcAddress("glVertexStream2dvATI");
+    glVertexStream3sATI = (glVertexStream3sATIPROC) extgl_GetProcAddress("glVertexStream3sATI");
+    glVertexStream3svATI = (glVertexStream3svATIPROC) extgl_GetProcAddress("glVertexStream3svATI");
+    glVertexStream3iATI = (glVertexStream3iATIPROC) extgl_GetProcAddress("glVertexStream3iATI");
+    glVertexStream3ivATI = (glVertexStream3ivATIPROC) extgl_GetProcAddress("glVertexStream3ivATI");
+    glVertexStream3fATI = (glVertexStream3fATIPROC) extgl_GetProcAddress("glVertexStream3fATI");
+    glVertexStream3fvATI = (glVertexStream3fvATIPROC) extgl_GetProcAddress("glVertexStream3fvATI");
+    glVertexStream3dATI = (glVertexStream3dATIPROC) extgl_GetProcAddress("glVertexStream3dATI");
+    glVertexStream3dvATI = (glVertexStream3dvATIPROC) extgl_GetProcAddress("glVertexStream3dvATI");
+    glVertexStream4sATI = (glVertexStream4sATIPROC) extgl_GetProcAddress("glVertexStream4sATI");
+    glVertexStream4svATI = (glVertexStream4svATIPROC) extgl_GetProcAddress("glVertexStream4svATI");
+    glVertexStream4iATI = (glVertexStream4iATIPROC) extgl_GetProcAddress("glVertexStream4iATI");
+    glVertexStream4ivATI = (glVertexStream4ivATIPROC) extgl_GetProcAddress("glVertexStream4ivATI");
+    glVertexStream4fATI = (glVertexStream4fATIPROC) extgl_GetProcAddress("glVertexStream4fATI");
+    glVertexStream4fvATI = (glVertexStream4fvATIPROC) extgl_GetProcAddress("glVertexStream4fvATI");
+    glVertexStream4dATI = (glVertexStream4dATIPROC) extgl_GetProcAddress("glVertexStream4dATI");
+    glVertexStream4dvATI = (glVertexStream4dvATIPROC) extgl_GetProcAddress("glVertexStream4dvATI");
+    glNormalStream3bATI = (glNormalStream3bATIPROC) extgl_GetProcAddress("glNormalStream3bATI");
+    glNormalStream3bvATI = (glNormalStream3bvATIPROC) extgl_GetProcAddress("glNormalStream3bvATI");
+    glNormalStream3sATI = (glNormalStream3sATIPROC) extgl_GetProcAddress("glNormalStream3sATI");
+    glNormalStream3svATI = (glNormalStream3svATIPROC) extgl_GetProcAddress("glNormalStream3svATI");
+    glNormalStream3iATI = (glNormalStream3iATIPROC) extgl_GetProcAddress("glNormalStream3iATI");
+    glNormalStream3ivATI = (glNormalStream3ivATIPROC) extgl_GetProcAddress("glNormalStream3ivATI");
+    glNormalStream3fATI = (glNormalStream3fATIPROC) extgl_GetProcAddress("glNormalStream3fATI");
+    glNormalStream3fvATI = (glNormalStream3fvATIPROC) extgl_GetProcAddress("glNormalStream3fvATI");
+    glNormalStream3dATI = (glNormalStream3dATIPROC) extgl_GetProcAddress("glNormalStream3dATI");
+    glNormalStream3dvATI = (glNormalStream3dvATIPROC) extgl_GetProcAddress("glNormalStream3dvATI");
+#endif
+}
+
+void extgl_InitATIElementArray()
+{
+#ifdef GL_ATI_element_array
+    if (!extgl_Extensions.ATI_element_array)
+        return;
+    glElementPointerATI = (glElementPointerATIPROC) extgl_GetProcAddress("glElementPointerATI");
+    glDrawElementArrayATI = (glDrawElementArrayATIPROC) extgl_GetProcAddress("glDrawElementArrayATI");
+    glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC) extgl_GetProcAddress("glDrawRangeElementArrayATI");
+#endif
+}
+
+void extgl_InitATIFragmentShader()
+{
+#ifdef GL_ATI_fragment_shader
+    if (!extgl_Extensions.ATI_fragment_shader)
+        return;
+    glGenFragmentShadersATI = (glGenFragmentShadersATIPROC) extgl_GetProcAddress("glGenFragmentShadersATI");
+    glBindFragmentShaderATI = (glBindFragmentShaderATIPROC) extgl_GetProcAddress("glBindFragmentShaderATI");
+    glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC) extgl_GetProcAddress("glDeleteFragmentShaderATI");
+    glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC) extgl_GetProcAddress("glBeginFragmentShaderATI");
+    glEndFragmentShaderATI = (glEndFragmentShaderATIPROC) extgl_GetProcAddress("glEndFragmentShaderATI");
+    glPassTexCoordATI = (glPassTexCoordATIPROC) extgl_GetProcAddress("glPassTexCoordATI");
+    glSampleMapATI = (glSampleMapATIPROC) extgl_GetProcAddress("glSampleMapATI");
+    glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC) extgl_GetProcAddress("glColorFragmentOp1ATI");
+    glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC) extgl_GetProcAddress("glColorFragmentOp2ATI");
+    glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC) extgl_GetProcAddress("glColorFragmentOp3ATI");
+    glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp1ATI");
+    glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp2ATI");
+    glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC) extgl_GetProcAddress("glAlphaFragmentOp3ATI");
+    glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC) extgl_GetProcAddress("glSetFragmentShaderConstantATI");
+#endif
+}
+
+
+void extgl_InitATIEnvmapBumpmap()
+{
+#ifdef GL_ATI_envmap_bumpmap
+    if (!extgl_Extensions.ATI_envmap_bumpmap)
+        return;
+    glTexBumpParameterivATI = (glTexBumpParameterivATIPROC) extgl_GetProcAddress("glTexBumpParameterivATI");
+    glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC) extgl_GetProcAddress("glTexBumpParameterfvATI");
+    glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC) extgl_GetProcAddress("glGetTexBumpParameterivATI");
+    glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC) extgl_GetProcAddress("glGetTexBumpParameterfvATI");
+#endif
+}
+
+void extgl_InitEXTVertexShader()
+{
+#ifdef GL_EXT_vertex_shader
+    if (!extgl_Extensions.EXT_vertex_shader)
+        return;
+    glBeginVertexShaderEXT = (glBeginVertexShaderEXTPROC) extgl_GetProcAddress("glBeginVertexShaderEXT");
+    glEndVertexShaderEXT = (glEndVertexShaderEXTPROC) extgl_GetProcAddress("glEndVertexShaderEXT");
+    glBindVertexShaderEXT = (glBindVertexShaderEXTPROC) extgl_GetProcAddress("glBindVertexShaderEXT");
+    glGenVertexShadersEXT = (glGenVertexShadersEXTPROC) extgl_GetProcAddress("glGenVertexShadersEXT");
+    glDeleteVertexShaderEXT = (glDeleteVertexShaderEXTPROC) extgl_GetProcAddress("glDeleteVertexShaderEXT");
+    glShaderOp1EXT = (glShaderOp1EXTPROC) extgl_GetProcAddress("glShaderOp1EXT");
+    glShaderOp2EXT = (glShaderOp2EXTPROC) extgl_GetProcAddress("glShaderOp2EXT");
+    glShaderOp3EXT = (glShaderOp3EXTPROC) extgl_GetProcAddress("glShaderOp3EXT");
+    glSwizzleEXT = (glSwizzleEXTPROC) extgl_GetProcAddress("glSwizzleEXT");
+    glWriteMaskEXT = (glWriteMaskEXTPROC) extgl_GetProcAddress("glWriteMaskEXT");
+    glInsertComponentEXT = (glInsertComponentEXTPROC) extgl_GetProcAddress("glInsertComponentEXT");
+    glExtractComponentEXT = (glExtractComponentEXTPROC) extgl_GetProcAddress("glExtractComponentEXT");
+    glGenSymbolsEXT = (glGenSymbolsEXTPROC) extgl_GetProcAddress("glGenSymbolsEXT");
+    glSetInvariantEXT = (glSetInvariantEXTPROC) extgl_GetProcAddress("glSetInvarianceEXT");
+    glSetLocalConstantEXT = (glSetLocalConstantEXTPROC) extgl_GetProcAddress("glSetLocalConstantEXT");
+    glVariantbvEXT = (glVariantbvEXTPROC) extgl_GetProcAddress("glVariantbvEXT");
+    glVariantsvEXT = (glVariantsvEXTPROC) extgl_GetProcAddress("glVariantsvEXT");
+    glVariantivEXT = (glVariantivEXTPROC) extgl_GetProcAddress("glVariantivEXT");
+    glVariantfvEXT = (glVariantfvEXTPROC) extgl_GetProcAddress("glVariantfvEXT");
+    glVariantdvEXT = (glVariantdvEXTPROC) extgl_GetProcAddress("glVariantdvEXT");
+    glVariantubvEXT = (glVariantubvEXTPROC) extgl_GetProcAddress("glVariantubvEXT");
+    glVariantusvEXT = (glVariantusvEXTPROC) extgl_GetProcAddress("glVariantusvEXT");
+    glVariantuivEXT = (glVariantuivEXTPROC) extgl_GetProcAddress("glVariantuivEXT");
+    glVariantPointerEXT = (glVariantPointerEXTPROC) extgl_GetProcAddress("glVariantPointerEXT");
+    glEnableVariantClientStateEXT = (glEnableVariantClientStateEXTPROC) extgl_GetProcAddress("glEnableVariantClientStateEXT");
+    glDisableVariantClientStateEXT = (glDisableVariantClientStateEXTPROC) extgl_GetProcAddress("glDisableVariantClientStateEXT");
+    glBindLightParameterEXT = (glBindLightParameterEXTPROC) extgl_GetProcAddress("glBindLightParameterEXT");
+    glBindMaterialParameterEXT = (glBindMaterialParameterEXTPROC) extgl_GetProcAddress("glBindMaterialParameterEXT");
+    glBindTexGenParameterEXT = (glBindTexGenParameterEXTPROC) extgl_GetProcAddress("glBindTexGenParameterEXT");
+    glBindTextureUnitParameterEXT = (glBindTextureUnitParameterEXTPROC) extgl_GetProcAddress("glBindTextureUnitParameterEXT");
+    glBindParameterEXT = (glBindParameterEXTPROC) extgl_GetProcAddress("glBindParameterEXT");
+    glIsVariantEnabledEXT = (glIsVariantEnabledEXTPROC) extgl_GetProcAddress("glIsVariantEnabledEXT");
+    glGetVariantBooleanvEXT = (glGetVariantBooleanvEXTPROC) extgl_GetProcAddress("glGetVariantBooleanvEXT");
+    glGetVariantIntegervEXT = (glGetVariantIntegervEXTPROC) extgl_GetProcAddress("glGetVariantIntegervEXT");
+    glGetVariantFloatvEXT = (glGetVariantFloatvEXTPROC) extgl_GetProcAddress("glGetVariantFloatvEXT");
+    glGetVariantPointervEXT = (glGetVariantPointervEXTPROC) extgl_GetProcAddress("glGetVariantPointervEXT");
+    glGetInvariantBooleanvEXT = (glGetInvariantBooleanvEXTPROC) extgl_GetProcAddress("glGetInvariantBooleanvEXT");
+    glGetInvariantIntegervEXT = (glGetInvariantIntegervEXTPROC) extgl_GetProcAddress("glGetInvariantIntegervEXT");
+    glGetInvariantFloatvEXT = (glGetInvariantFloatvEXTPROC) extgl_GetProcAddress("glGetInvariantFloatvEXT");
+    glGetLocalConstantBooleanvEXT = (glGetLocalConstantBooleanvEXTPROC) extgl_GetProcAddress("glGetLocalConstantBooleanvEXT");
+    glGetLocalConstantIntegervEXT = (glGetLocalConstantIntegervEXTPROC) extgl_GetProcAddress("glGetLocalConstantIntegervEXT");
+    glGetLocalConstantFloatvEXT = (glGetLocalConstantFloatvEXTPROC) extgl_GetProcAddress("glGetLocalConstantFloatvEXT");
+#endif
+}
+
+void extgl_InitARBMatrixPalette()
+{
+#ifdef GL_ARB_matrix_palette
+    if (!extgl_Extensions.ARB_matrix_palette)
+        return;
+    glCurrentPaletteMatrixARB = (glCurrentPaletteMatrixARBPROC) extgl_GetProcAddress("glCurrentPaletteMatrixARB");
+    glMatrixIndexubvARB = (glMatrixIndexubvARBPROC) extgl_GetProcAddress("glMatrixIndexubvARB");
+    glMatrixIndexusvARB = (glMatrixIndexusvARBPROC) extgl_GetProcAddress("glMatrixIndexusvARB");
+    glMatrixIndexuivARB = (glMatrixIndexuivARBPROC) extgl_GetProcAddress("glMatrixIndexuivARB");
+    glMatrixIndexPointerARB = (glMatrixIndexPointerARBPROC) extgl_GetProcAddress("glMatrixIndexPointerARB");
+#endif
+}
+
+void extgl_InitEXTMultiDrawArrays()
+{
+#ifdef GL_EXT_multi_draw_arrays
+    if (!extgl_Extensions.EXT_multi_draw_arrays)
+        return;
+    glMultiDrawArraysEXT = (glMultiDrawArraysEXTPROC) extgl_GetProcAddress("glMultiDrawArraysEXT");
+    glMultiDrawElementsEXT = (glMultiDrawElementsEXTPROC) extgl_GetProcAddress("glMultiDrawElementsEXT");
+#endif
+}
+
+void extgl_InitARBVertexBlend()
+{
+#ifdef GL_ARB_vertex_blend
+    if (!extgl_Extensions.ARB_vertex_blend)
+        return;
+    glWeightbvARB = (glWeightbvARBPROC) extgl_GetProcAddress("glWeightbvARB");
+    glWeightsvARB = (glWeightsvARBPROC) extgl_GetProcAddress("glWeightsvARB");
+    glWeightivARB = (glWeightivARBPROC) extgl_GetProcAddress("glWeightivARB");
+    glWeightfvARB = (glWeightfvARBPROC) extgl_GetProcAddress("glWeightfvARB");
+    glWeightdvARB = (glWeightdvARBPROC) extgl_GetProcAddress("glWeightdvARB");
+    glWeightubvARB = (glWeightubvARBPROC) extgl_GetProcAddress("glWeightubvARB");
+    glWeightusvARB = (glWeightusvARBPROC) extgl_GetProcAddress("glWeightusvARB");
+    glWeightuivARB = (glWeightuivARBPROC) extgl_GetProcAddress("glWeightuivARB");
+    glWeightPointerARB = (glWeightPointerARBPROC) extgl_GetProcAddress("glWeightPointerARB");
+    glVertexBlendARB = (glVertexBlendARBPROC) extgl_GetProcAddress("glVertexBlendARB");
+#endif
+}
+
+void extgl_InitARBPointParameters()
+{
+#ifdef GL_ARB_point_parameters
+    if (!extgl_Extensions.ARB_point_parameters)
+        return;
+    glPointParameterfARB = (glPointParameterfARBPROC) extgl_GetProcAddress("glPointParameterfARB");
+    glPointParameterfvARB = (glPointParameterfvARBPROC) extgl_GetProcAddress("glPointParameterfvARB");
+#endif
+}
+
+void extgl_InitATIPNTriangles()
+{
+#ifdef GL_ATI_pn_triangles
+    if (!extgl_Extensions.ATI_pn_triangles)
+        return;
+    glPNTrianglesiATI = (glPNTrianglesiATIPROC) extgl_GetProcAddress("glPNTrianglesiATI");
+    glPNTrianglesfATI = (glPNTrianglesfATIPROC) extgl_GetProcAddress("glPNTrianglesfATI");
+#endif
+}
+
+void extgl_InitNVEvaluators()
+{
+#ifdef GL_NV_evaluators
+    if (!extgl_Extensions.NV_evaluators)
+        return;
+    glMapControlPointsNV = (glMapControlPointsNVPROC) extgl_GetProcAddress("glMapControlPointsNV");
+    glMapParameterivNV = (glMapParameterivNVPROC) extgl_GetProcAddress("glMapParameterivNV");
+    glMapParameterfvNV = (glMapParameterfvNVPROC) extgl_GetProcAddress("glMapParameterfvNV");
+    glGetMapControlPointsNV = (glGetMapControlPointsNVPROC) extgl_GetProcAddress("glGetMapControlPointsNV");
+    glGetMapParameterivNV = (glGetMapParameterivNVPROC) extgl_GetProcAddress("glGetMapParameterivNV");
+    glGetMapParameterfvNV = (glGetMapParameterfvNVPROC) extgl_GetProcAddress("glGetMapParameterfvNV");
+    glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC) extgl_GetProcAddress("glGetMapAttribParameterivNV");
+    glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC) extgl_GetProcAddress("glGetMapAttribParameterfvNV");
+    glEvalMapsNV = (glEvalMapsNVPROC) extgl_GetProcAddress("glEvalMapsNV");
+#endif
+}
+
+void extgl_InitNVRegisterCombiners2()
+{
+#ifdef GL_NV_register_combiners
+    if (!extgl_Extensions.NV_register_combiners2)
+        return;
+    glCombinerStageParameterfvNV = (glCombinerStageParameterfvNVPROC) extgl_GetProcAddress("glCombinerStageParameterfvNV");
+    glGetCombinerStageParameterfvNV = (glGetCombinerStageParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerStageParameterfvNV");
+#endif
+}
+
+void extgl_InitNVFence()
+{
+#ifdef GL_NV_fence
+    if (!extgl_Extensions.NV_fence)
+        return;
+    glGenFencesNV = (glGenFencesNVPROC) extgl_GetProcAddress("glGenFencesNV");
+    glDeleteFencesNV = (glDeleteFencesNVPROC) extgl_GetProcAddress("glDeleteFencesNV");
+    glSetFenceNV = (glSetFenceNVPROC) extgl_GetProcAddress("glSetFenceNV");
+    glTestFenceNV = (glTestFenceNVPROC) extgl_GetProcAddress("glTestFenceNV");
+    glFinishFenceNV = (glFinishFenceNVPROC) extgl_GetProcAddress("glFinishFenceNV");
+    glIsFenceNV = (glIsFenceNVPROC) extgl_GetProcAddress("glIsFenceNV");
+    glGetFenceivNV = (glGetFenceivNVPROC) extgl_GetProcAddress("glGetFenceivNV");
+#endif
+}
+
+void extgl_InitNVVertexProgram()
+{
+#ifdef GL_NV_vertex_program
+    if (!extgl_Extensions.NV_vertex_program)
+        return;
+    glBindProgramNV = (glBindProgramNVPROC) extgl_GetProcAddress("glBindProgramNV");
+    glDeleteProgramsNV = (glDeleteProgramsNVPROC) extgl_GetProcAddress("glDeleteProgramsNV");
+    glExecuteProgramNV = (glExecuteProgramNVPROC) extgl_GetProcAddress("glExecuteProgramNV");
+    glGenProgramsNV = (glGenProgramsNVPROC) extgl_GetProcAddress("glGenProgramsNV");
+    glAreProgramsResidentNV = (glAreProgramsResidentNVPROC) extgl_GetProcAddress("glAreProgramsResidentNV");
+    glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC) extgl_GetProcAddress("glRequestResidentProgramsNV");
+    glGetProgramParameterfvNV = (glGetProgramParameterfvNVPROC) extgl_GetProcAddress("glGetProgramParameterfvNV");
+    glGetProgramParameterdvNV = (glGetProgramParameterdvNVPROC) extgl_GetProcAddress("glGetProgramParameterdvNV");
+    glGetProgramivNV = (glGetProgramivNVPROC) extgl_GetProcAddress("glGetProgramivNV");
+    glGetProgramStringNV = (glGetProgramStringNVPROC) extgl_GetProcAddress("glGetProgramStringNV");
+    glGetTrackMatrixivNV = (glGetTrackMatrixivNVPROC) extgl_GetProcAddress("glGetTrackMatrixivNV");
+    glGetVertexAttribdvNV = (glGetVertexAttribdvNVPROC) extgl_GetProcAddress("glGetVertexAttribdvNV");
+    glGetVertexAttribfvNV = (glGetVertexAttribfvNVPROC) extgl_GetProcAddress("glGetVertexAttribfvNV");
+    glGetVertexAttribivNV = (glGetVertexAttribivNVPROC) extgl_GetProcAddress("glGetVertexAttribivNV");
+    glGetVertexAttribPointervNV = (glGetVertexAttribPointervNVPROC) extgl_GetProcAddress("glGetVertexAttribPointervNV");
+    glIsProgramNV = (glIsProgramNVPROC) extgl_GetProcAddress("glIsProgramNV");
+    glLoadProgramNV = (glLoadProgramNVPROC) extgl_GetProcAddress("glLoadProgramNV");
+    glProgramParameter4fNV = (glProgramParameter4fNVPROC) extgl_GetProcAddress("glProgramParameter4fNV");
+    glProgramParameter4dNV = (glProgramParameter4dNVPROC) extgl_GetProcAddress("glProgramParameter4dNV");
+    glProgramParameter4dvNV = (glProgramParameter4dvNVPROC) extgl_GetProcAddress("glProgramParameter4dvNV");
+    glProgramParameter4fvNV = (glProgramParameter4fvNVPROC) extgl_GetProcAddress("glProgramParameter4fvNV");
+    glProgramParameters4dvNV = (glProgramParameters4dvNVPROC) extgl_GetProcAddress("glProgramParameters4dvNV");
+    glProgramParameters4fvNV = (glProgramParameters4fvNVPROC) extgl_GetProcAddress("glProgramParameters4fvNV");
+    glTrackMatrixNV = (glTrackMatrixNVPROC) extgl_GetProcAddress("glTrackMatrixNV");
+    glVertexAttribPointerNV = (glVertexAttribPointerNVPROC) extgl_GetProcAddress("glVertexAttribPointerNV");
+    glVertexAttrib1sNV = (glVertexAttrib1sNVPROC) extgl_GetProcAddress("glVertexAttrib1sNV");
+    glVertexAttrib1fNV = (glVertexAttrib1fNVPROC) extgl_GetProcAddress("glVertexAttrib1fNV");
+    glVertexAttrib1dNV = (glVertexAttrib1dNVPROC) extgl_GetProcAddress("glVertexAttrib1dNV");
+    glVertexAttrib2sNV = (glVertexAttrib2sNVPROC) extgl_GetProcAddress("glVertexAttrib2sNV");
+    glVertexAttrib2fNV = (glVertexAttrib2fNVPROC) extgl_GetProcAddress("glVertexAttrib2fNV");
+    glVertexAttrib2dNV = (glVertexAttrib2dNVPROC) extgl_GetProcAddress("glVertexAttrib2dNV");
+    glVertexAttrib3sNV = (glVertexAttrib3sNVPROC) extgl_GetProcAddress("glVertexAttrib3sNV");
+    glVertexAttrib3fNV = (glVertexAttrib3fNVPROC) extgl_GetProcAddress("glVertexAttrib3fNV");
+    glVertexAttrib3dNV = (glVertexAttrib3dNVPROC) extgl_GetProcAddress("glVertexAttrib3dNV");
+    glVertexAttrib4sNV = (glVertexAttrib4sNVPROC) extgl_GetProcAddress("glVertexAttrib4sNV");
+    glVertexAttrib4fNV = (glVertexAttrib4fNVPROC) extgl_GetProcAddress("glVertexAttrib4fNV");
+    glVertexAttrib4dNV = (glVertexAttrib4dNVPROC) extgl_GetProcAddress("glVertexAttrib4dNV");
+    glVertexAttrib4ubNV = (glVertexAttrib4ubNVPROC) extgl_GetProcAddress("glVertexAttrib4ubNV");
+    glVertexAttrib1svNV = (glVertexAttrib1svNVPROC) extgl_GetProcAddress("glVertexAttrib1svNV");
+    glVertexAttrib1fvNV = (glVertexAttrib1fvNVPROC) extgl_GetProcAddress("glVertexAttrib1fvNV");
+    glVertexAttrib1dvNV = (glVertexAttrib1dvNVPROC) extgl_GetProcAddress("glVertexAttrib1dvNV");
+    glVertexAttrib2svNV = (glVertexAttrib2svNVPROC) extgl_GetProcAddress("glVertexAttrib2svNV");
+    glVertexAttrib2fvNV = (glVertexAttrib2fvNVPROC) extgl_GetProcAddress("glVertexAttrib2fvNV");
+    glVertexAttrib2dvNV = (glVertexAttrib2dvNVPROC) extgl_GetProcAddress("glVertexAttrib2dvNV");
+    glVertexAttrib3svNV = (glVertexAttrib3svNVPROC) extgl_GetProcAddress("glVertexAttrib3svNV");
+    glVertexAttrib3fvNV = (glVertexAttrib3fvNVPROC) extgl_GetProcAddress("glVertexAttrib3fvNV");
+    glVertexAttrib3dvNV = (glVertexAttrib3dvNVPROC) extgl_GetProcAddress("glVertexAttrib3dvNV");
+    glVertexAttrib4svNV = (glVertexAttrib4svNVPROC) extgl_GetProcAddress("glVertexAttrib4svNV");
+    glVertexAttrib4fvNV = (glVertexAttrib4fvNVPROC) extgl_GetProcAddress("glVertexAttrib4fvNV");
+    glVertexAttrib4dvNV = (glVertexAttrib4dvNVPROC) extgl_GetProcAddress("glVertexAttrib4dvNV");
+    glVertexAttrib4ubvNV = (glVertexAttrib4ubvNVPROC) extgl_GetProcAddress("glVertexAttrib4ubvNV");
+    glVertexAttribs1svNV = (glVertexAttribs1svNVPROC) extgl_GetProcAddress("glVertexAttribs1svNV");
+    glVertexAttribs1fvNV = (glVertexAttribs1fvNVPROC) extgl_GetProcAddress("glVertexAttribs1fvNV");
+    glVertexAttribs1dvNV = (glVertexAttribs1dvNVPROC) extgl_GetProcAddress("glVertexAttribs1dvNV");
+    glVertexAttribs2svNV = (glVertexAttribs2svNVPROC) extgl_GetProcAddress("glVertexAttribs2svNV");
+    glVertexAttribs2fvNV = (glVertexAttribs2fvNVPROC) extgl_GetProcAddress("glVertexAttribs2fvNV");
+    glVertexAttribs2dvNV = (glVertexAttribs2dvNVPROC) extgl_GetProcAddress("glVertexAttribs2dvNV");
+    glVertexAttribs3svNV = (glVertexAttribs3svNVPROC) extgl_GetProcAddress("glVertexAttribs3svNV");
+    glVertexAttribs3fvNV = (glVertexAttribs3fvNVPROC) extgl_GetProcAddress("glVertexAttribs3fvNV");
+    glVertexAttribs3dvNV = (glVertexAttribs3dvNVPROC) extgl_GetProcAddress("glVertexAttribs3dvNV");
+    glVertexAttribs4svNV = (glVertexAttribs4svNVPROC) extgl_GetProcAddress("glVertexAttribs4svNV");
+    glVertexAttribs4fvNV = (glVertexAttribs4fvNVPROC) extgl_GetProcAddress("glVertexAttribs4fvNV");
+    glVertexAttribs4dvNV = (glVertexAttribs4dvNVPROC) extgl_GetProcAddress("glVertexAttribs4dvNV");
+    glVertexAttribs4ubvNV = (glVertexAttribs4ubvNVPROC) extgl_GetProcAddress("glVertexAttribs4ubvNV");
+#endif
+}
+
+void extgl_InitEXTVertexWeighting()
+{
+#ifdef GL_EXT_vertex_weighting
+    if (!extgl_Extensions.EXT_vertex_weighting)
+        return;
+    glVertexWeightfEXT = (glVertexWeightfEXTPROC) extgl_GetProcAddress("glVertexWeightfEXT");
+    glVertexWeightfvEXT = (glVertexWeightfvEXTPROC) extgl_GetProcAddress("glVertexWeightfvEXT");
+    glVertexWeightPointerEXT = (glVertexWeightPointerEXTPROC) extgl_GetProcAddress("glVertexWeightPointerEXT");
+#endif
+}
+
+void extgl_InitARBMultisample()
+{
+#ifdef GL_ARB_multisample
+    if (!extgl_Extensions.ARB_multisample)
+        return;
+    glSampleCoverageARB = (glSampleCoverageARBPROC) extgl_GetProcAddress("glSampleCoverageARB");
+#endif
+}
+
+void extgl_InitNVRegisterCombiners()
+{
+#ifdef GL_NV_register_combiners
+    if (!extgl_Extensions.NV_register_combiners)
+        return;
+    glCombinerParameterfvNV = (glCombinerParameterfvNVPROC) extgl_GetProcAddress("glCombinerParameterfvNV");
+    glCombinerParameterfNV = (glCombinerParameterfNVPROC) extgl_GetProcAddress("glCombinerParameterfNV");
+    glCombinerParameterivNV = (glCombinerParameterivNVPROC) extgl_GetProcAddress("glCombinerParameterivNV");
+    glCombinerParameteriNV = (glCombinerParameteriNVPROC) extgl_GetProcAddress("glCombinerParameteriNV");
+    glCombinerInputNV = (glCombinerInputNVPROC) extgl_GetProcAddress("glCombinerInputNV");
+    glCombinerOutputNV = (glCombinerOutputNVPROC) extgl_GetProcAddress("glCombinerOutputNV");
+    glFinalCombinerInputNV = (glFinalCombinerInputNVPROC) extgl_GetProcAddress("glFinalCombinerInputNV");
+    glGetCombinerInputParameterfvNV = (glGetCombinerInputParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerInputParameterfvNV");
+    glGetCombinerInputParameterivNV = (glGetCombinerInputParameterivNVPROC) extgl_GetProcAddress("glGetCombinerInputParameterivNV");
+    glGetCombinerOutputParameterfvNV = (glGetCombinerOutputParameterfvNVPROC) extgl_GetProcAddress("glGetCombinerOutputParameterfvNV");
+    glGetCombinerOutputParameterivNV = (glGetCombinerOutputParameterivNVPROC) extgl_GetProcAddress("glGetCombinerOutputParameterivNV");
+    glGetFinalCombinerInputParameterfvNV = (glGetFinalCombinerInputParameterfvNVPROC) extgl_GetProcAddress("glGetFinalCombinerInputParameterfvNV");
+    glGetFinalCombinerInputParameterivNV = (glGetFinalCombinerInputParameterivNVPROC) extgl_GetProcAddress("glGetFinalCombinerInputParameterivNV");
+#endif
+}
+
+void extgl_InitEXTPointParameters()
+{
+#ifdef GL_EXT_point_parameters
+    if (!extgl_Extensions.EXT_point_parameters)
+        return;
+    glPointParameterfEXT = (glPointParameterfEXTPROC) extgl_GetProcAddress("glPointParameterfEXT");
+    glPointParameterfvEXT = (glPointParameterfvEXTPROC) extgl_GetProcAddress("glPointParameterfvEXT");
+#endif
+}
+
+void extgl_InitNVVertexArrayRange()
+{
+#ifdef GL_NV_vertex_array_range
+    if (!extgl_Extensions.NV_vertex_array_range)
+        return;
+    glFlushVertexArrayRangeNV = (glFlushVertexArrayRangeNVPROC) extgl_GetProcAddress("glFlushVertexArrayRangeNV");
+    glVertexArrayRangeNV = (glVertexArrayRangeNVPROC) extgl_GetProcAddress("glVertexArrayRangeNV");
+#ifdef _WIN32
+    wglAllocateMemoryNV = (wglAllocateMemoryNVPROC) extgl_GetProcAddress("wglAllocateMemoryNV");
+    wglFreeMemoryNV = (wglFreeMemoryNVPROC) extgl_GetProcAddress("wglFreeMemoryNV");
+#else
+    glXAllocateMemoryNV = (glXAllocateMemoryNVPROC) extgl_GetProcAddress("glXAllocateMemoryNV");
+    glXFreeMemoryNV = (glXFreeMemoryNVPROC) extgl_GetProcAddress("glXFreeMemoryNV");
+#endif /* WIN32 */
+#endif
+}
+ 
+void extgl_InitEXTFogCoord()
+{
+#ifdef GL_EXT_fog_coord
+    if (!extgl_Extensions.EXT_fog_coord)
+        return;
+    glFogCoordfEXT = (glFogCoordfEXTPROC) extgl_GetProcAddress("glFogCoordfEXT");
+    glFogCoordfvEXT = (glFogCoordfvEXTPROC) extgl_GetProcAddress("glFogCoordfvEXT");
+    glFogCoorddEXT = (glFogCoorddEXTPROC) extgl_GetProcAddress("glFogCoorddEXT");
+    glFogCoorddvEXT = (glFogCoorddvEXTPROC) extgl_GetProcAddress("glFogCoorddvEXT");
+    glFogCoordPointerEXT = (glFogCoordPointerEXTPROC) extgl_GetProcAddress("glFogCoordPointerEXT");
+#endif
+}
+
+void extgl_InitEXTSecondaryColor()
+{
+#ifdef GL_EXT_secondary_color
+    if (!extgl_Extensions.EXT_secondary_color)
+        return;
+    glSecondaryColor3bEXT = (glSecondaryColor3bEXTPROC) extgl_GetProcAddress("glSecondaryColor3bEXT");
+    glSecondaryColor3bvEXT = (glSecondaryColor3bvEXTPROC) extgl_GetProcAddress("glSecondaryColor3bvEXT");
+    glSecondaryColor3dEXT = (glSecondaryColor3dEXTPROC) extgl_GetProcAddress("glSecondaryColor3dEXT");
+    glSecondaryColor3dvEXT = (glSecondaryColor3dvEXTPROC) extgl_GetProcAddress("glSecondaryColor3dvEXT");
+    glSecondaryColor3fEXT = (glSecondaryColor3fEXTPROC) extgl_GetProcAddress("glSecondaryColor3fEXT");
+    glSecondaryColor3fvEXT = (glSecondaryColor3fvEXTPROC) extgl_GetProcAddress("glSecondaryColor3fvEXT");
+    glSecondaryColor3iEXT = (glSecondaryColor3iEXTPROC) extgl_GetProcAddress("glSecondaryColor3iEXT");
+    glSecondaryColor3ivEXT = (glSecondaryColor3ivEXTPROC) extgl_GetProcAddress("glSecondaryColor3ivEXT");
+    glSecondaryColor3sEXT = (glSecondaryColor3sEXTPROC) extgl_GetProcAddress("glSecondaryColor3sEXT");
+    glSecondaryColor3svEXT = (glSecondaryColor3svEXTPROC) extgl_GetProcAddress("glSecondaryColor3svEXT");
+    glSecondaryColor3ubEXT = (glSecondaryColor3ubEXTPROC) extgl_GetProcAddress("glSecondaryColor3ubEXT");
+    glSecondaryColor3ubvEXT = (glSecondaryColor3ubvEXTPROC) extgl_GetProcAddress("glSecondaryColor3ubvEXT");
+    glSecondaryColor3uiEXT = (glSecondaryColor3uiEXTPROC) extgl_GetProcAddress("glSecondaryColor3uiEXT");
+    glSecondaryColor3uivEXT = (glSecondaryColor3uivEXTPROC) extgl_GetProcAddress("glSecondaryColor3uivEXT");
+    glSecondaryColor3usEXT = (glSecondaryColor3usEXTPROC) extgl_GetProcAddress("glSecondaryColor3usEXT");
+    glSecondaryColor3usvEXT = (glSecondaryColor3usvEXTPROC) extgl_GetProcAddress("glSecondaryColor3usvEXT");
+    glSecondaryColorPointerEXT = (glSecondaryColorPointerEXTPROC) extgl_GetProcAddress("glSecondaryColorPointerEXT");
+#endif
+}
+
+void extgl_InitEXTCompiledVertexArray()
+{
+#ifdef GL_EXT_compiled_vertex_array
+    if (!extgl_Extensions.EXT_compiled_vertex_array)
+        return;
+    glLockArraysEXT = (glLockArraysEXTPROC) extgl_GetProcAddress("glLockArraysEXT");
+    glUnlockArraysEXT = (glUnlockArraysEXTPROC) extgl_GetProcAddress("glUnlockArraysEXT");
+#endif
+}
+
+void extgl_InitARBTransposeMatrix()
+{
+#ifdef GL_ARB_transpose_matrix
+    if (!extgl_Extensions.ARB_transpose_matrix)
+        return;
+    glLoadTransposeMatrixfARB = (glLoadTransposeMatrixfARBPROC) extgl_GetProcAddress("glLoadTransposeMatrixfARB");
+    glLoadTransposeMatrixdARB = (glLoadTransposeMatrixdARBPROC) extgl_GetProcAddress("glLoadTransposeMatrixdARB");
+    glMultTransposeMatrixfARB = (glMultTransposeMatrixfARBPROC) extgl_GetProcAddress("glMultTransposeMatrixfARB");
+    glMultTransposeMatrixdARB = (glMultTransposeMatrixdARBPROC) extgl_GetProcAddress("glMultTransposeMatrixdARB");
+#endif
+}
+
+void extgl_InitEXTDrawRangeElements()
+{
+#ifdef GL_EXT_draw_range_elements
+    if (!extgl_Extensions.EXT_draw_range_elements)
+        return;
+    glDrawRangeElementsEXT = (glDrawRangeElementsEXTPROC) extgl_GetProcAddress("glDrawRangeElementsEXT");
+#endif
+}
+
+void extgl_InitARBMultitexture()
+{
+#ifdef _WIN32
+#ifdef GL_ARB_multitexture
+    if (!extgl_Extensions.ARB_multitexture)
+        return;
+    glActiveTextureARB = (glActiveTextureARBPROC) extgl_GetProcAddress("glActiveTextureARB");
+    glClientActiveTextureARB = (glClientActiveTextureARBPROC) extgl_GetProcAddress("glClientActiveTextureARB");
+
+    glMultiTexCoord1dARB = (glMultiTexCoord1dARBPROC) extgl_GetProcAddress("glMultiTexCoord1dARB");
+    glMultiTexCoord1dvARB = (glMultiTexCoord1dvARBPROC) extgl_GetProcAddress("glMultiTexCoord1dvARB");
+    glMultiTexCoord1fARB = (glMultiTexCoord1fARBPROC) extgl_GetProcAddress("glMultiTexCoord1fARB");
+    glMultiTexCoord1fvARB = (glMultiTexCoord1fvARBPROC) extgl_GetProcAddress("glMultiTexCoord1fvARB");
+    glMultiTexCoord1iARB = (glMultiTexCoord1iARBPROC) extgl_GetProcAddress("glMultiTexCoord1iARB");
+    glMultiTexCoord1ivARB = (glMultiTexCoord1ivARBPROC) extgl_GetProcAddress("glMultiTexCoord1ivARB");
+    glMultiTexCoord1sARB = (glMultiTexCoord1sARBPROC) extgl_GetProcAddress("glMultiTexCoord1sARB");
+    glMultiTexCoord1svARB = (glMultiTexCoord1svARBPROC) extgl_GetProcAddress("glMultiTexCoord1svARB");
+
+    glMultiTexCoord2dARB = (glMultiTexCoord2dARBPROC) extgl_GetProcAddress("glMultiTexCoord2dARB");
+    glMultiTexCoord2dvARB = (glMultiTexCoord2dvARBPROC) extgl_GetProcAddress("glMultiTexCoord2dvARB");
+    glMultiTexCoord2fARB = (glMultiTexCoord2fARBPROC) extgl_GetProcAddress("glMultiTexCoord2fARB");
+    glMultiTexCoord2fvARB = (glMultiTexCoord2fvARBPROC) extgl_GetProcAddress("glMultiTexCoord2fvARB");
+    glMultiTexCoord2iARB = (glMultiTexCoord2iARBPROC) extgl_GetProcAddress("glMultiTexCoord2iARB");
+    glMultiTexCoord2ivARB = (glMultiTexCoord2ivARBPROC) extgl_GetProcAddress("glMultiTexCoord2ivARB");
+    glMultiTexCoord2sARB = (glMultiTexCoord2sARBPROC) extgl_GetProcAddress("glMultiTexCoord2sARB");
+    glMultiTexCoord2svARB = (glMultiTexCoord2svARBPROC) extgl_GetProcAddress("glMultiTexCoord2svARB");
+
+    glMultiTexCoord3dARB = (glMultiTexCoord3dARBPROC) extgl_GetProcAddress("glMultiTexCoord3dARB");
+    glMultiTexCoord3dvARB = (glMultiTexCoord3dvARBPROC) extgl_GetProcAddress("glMultiTexCoord3dvARB");
+    glMultiTexCoord3fARB = (glMultiTexCoord3fARBPROC) extgl_GetProcAddress("glMultiTexCoord3fARB");
+    glMultiTexCoord3fvARB = (glMultiTexCoord3fvARBPROC) extgl_GetProcAddress("glMultiTexCoord3fvARB");
+    glMultiTexCoord3iARB = (glMultiTexCoord3iARBPROC) extgl_GetProcAddress("glMultiTexCoord3iARB");
+    glMultiTexCoord3ivARB = (glMultiTexCoord3ivARBPROC) extgl_GetProcAddress("glMultiTexCoord3ivARB");
+    glMultiTexCoord3sARB = (glMultiTexCoord3sARBPROC) extgl_GetProcAddress("glMultiTexCoord3sARB");
+    glMultiTexCoord3svARB = (glMultiTexCoord3svARBPROC) extgl_GetProcAddress("glMultiTexCoord3svARB");
+
+    glMultiTexCoord4dARB = (glMultiTexCoord4dARBPROC) extgl_GetProcAddress("glMultiTexCoord4dARB");
+    glMultiTexCoord4dvARB = (glMultiTexCoord4dvARBPROC) extgl_GetProcAddress("glMultiTexCoord4dvARB");
+    glMultiTexCoord4fARB = (glMultiTexCoord4fARBPROC) extgl_GetProcAddress("glMultiTexCoord4fARB");
+    glMultiTexCoord4fvARB = (glMultiTexCoord4fvARBPROC) extgl_GetProcAddress("glMultiTexCoord4fvARB");
+    glMultiTexCoord4iARB = (glMultiTexCoord4iARBPROC) extgl_GetProcAddress("glMultiTexCoord4iARB");
+    glMultiTexCoord4ivARB = (glMultiTexCoord4ivARBPROC) extgl_GetProcAddress("glMultiTexCoord4ivARB");
+    glMultiTexCoord4sARB = (glMultiTexCoord4sARBPROC) extgl_GetProcAddress("glMultiTexCoord4sARB");
+    glMultiTexCoord4svARB = (glMultiTexCoord4svARBPROC) extgl_GetProcAddress("glMultiTexCoord4svARB");
+#endif /* GL_ARB_multitexture */
+#endif /* WIN32 */
+}
+
+void extgl_InitOpenGL1_2()
+{
+#ifdef _WIN32
+#ifdef GL_VERSION_1_2
+    if (!extgl_Extensions.OpenGL12)
+        return;
+    glTexImage3D = (glTexImage3DPROC) extgl_GetProcAddress("glTexImage3D");
+    glTexSubImage3D = (glTexSubImage3DPROC) extgl_GetProcAddress("glTexSubImage3D");
+    glCopyTexSubImage3D = (glCopyTexSubImage3DPROC) extgl_GetProcAddress("glCopyTexSubImage3D");
+    glDrawRangeElements = (glDrawRangeElementsPROC) extgl_GetProcAddress("glDrawRangeElements");
+#endif /* GL_VERSION_1_2 */
+#endif /* WIN32 */
+}
+
+void extgl_InitARBImaging()
+{
+#ifdef _WIN32
+#ifdef GL_ARB_imaging
+    if (!extgl_Extensions.ARB_imaging)
+        return;
+    glBlendColor = (glBlendColorPROC) extgl_GetProcAddress("glBlendColor");
+    glBlendEquation = (glBlendEquationPROC) extgl_GetProcAddress("glBlendEquation");
+    glColorTable = (glColorTablePROC) extgl_GetProcAddress("glColorTable");
+    glColorTableParameterfv = (glColorTableParameterfvPROC) extgl_GetProcAddress("glColorTableParameterfv");
+    glColorTableParameteriv = (glColorTableParameterivPROC) extgl_GetProcAddress("glColorTableParameteriv");
+    glCopyColorTable = (glCopyColorTablePROC) extgl_GetProcAddress("glCopyColorTable");
+    glGetColorTable = (glGetColorTablePROC) extgl_GetProcAddress("glGetColorTable");
+    glGetColorTableParameterfv = (glGetColorTableParameterfvPROC) extgl_GetProcAddress("glGetColorTableParameterfv");
+    glGetColorTableParameteriv = (glGetColorTableParameterivPROC) extgl_GetProcAddress("glGetColorTableParameteriv");
+    glColorSubTable = (glColorSubTablePROC) extgl_GetProcAddress("glColorSubTable");
+    glCopyColorSubTable = (glCopyColorSubTablePROC) extgl_GetProcAddress("glCopyColorSubTable");
+    glConvolutionFilter1D = (glConvolutionFilter1DPROC) extgl_GetProcAddress("glConvolutionFilter1D");
+    glConvolutionFilter2D = (glConvolutionFilter2DPROC) extgl_GetProcAddress("glConvolutionFilter2D");
+    glConvolutionParameterf = (glConvolutionParameterfPROC) extgl_GetProcAddress("glConvolutionParameterf");
+    glConvolutionParameterfv = (glConvolutionParameterfvPROC) extgl_GetProcAddress("glConvolutionParameterfv");
+    glConvolutionParameteri = (glConvolutionParameteriPROC) extgl_GetProcAddress("glConvolutionParameteri");
+    glConvolutionParameteriv = (glConvolutionParameterivPROC) extgl_GetProcAddress("glConvolutionParameteriv");
+    glCopyConvolutionFilter1D = (glCopyConvolutionFilter1DPROC) extgl_GetProcAddress("glCopyConvolutionFilter1D");
+    glCopyConvolutionFilter2D = (glCopyConvolutionFilter2DPROC) extgl_GetProcAddress("glCopyConvolutionFilter2D");
+    glGetConvolutionFilter = (glGetConvolutionFilterPROC) extgl_GetProcAddress("glGetConvolutionFilter");
+    glGetConvolutionParameterfv = (glGetConvolutionParameterfvPROC) extgl_GetProcAddress("glGetConvolutionParameterfv");
+    glGetConvolutionParameteriv = (glGetConvolutionParameterivPROC) extgl_GetProcAddress("glGetConvolutionParameteriv");
+    glGetSeparableFilter = (glGetSeparableFilterPROC) extgl_GetProcAddress("glGetSeparableFilter");
+    glSeparableFilter2D = (glSeparableFilter2DPROC) extgl_GetProcAddress("glSeparableFilter2D");
+    glGetHistogram = (glGetHistogramPROC) extgl_GetProcAddress("glGetHistogram");
+    glGetHistogramParameterfv = (glGetHistogramParameterfvPROC) extgl_GetProcAddress("glGetHistogramParameterfv");
+    glGetHistogramParameteriv = (glGetHistogramParameterivPROC) extgl_GetProcAddress("glGetHistogramParameteriv");
+    glGetMinmax = (glGetMinmaxPROC) extgl_GetProcAddress("glGetMinmax");
+    glGetMinmaxParameterfv = (glGetMinmaxParameterfvPROC) extgl_GetProcAddress("glGetMinmaxParameterfv");
+    glGetMinmaxParameteriv = (glGetMinmaxParameterivPROC) extgl_GetProcAddress("glGetMinmaxParameteriv");
+    glHistogram = (glHistogramPROC) extgl_GetProcAddress("glHistogram");
+    glMinmax = (glMinmaxPROC) extgl_GetProcAddress("glMinmax");
+    glResetHistogram = (glResetHistogramPROC) extgl_GetProcAddress("glResetHistogram");
+    glResetMinmax = (glResetMinmaxPROC) extgl_GetProcAddress("glResetMinmax");
+#endif /* GL_ARB_imaging */
+#endif /* WIN32 */
+}
+
+void extgl_InitOpenGL1_3()
+{
+#ifdef _WIN32
+#ifdef GL_VERSION_1_3
+    if (!extgl_Extensions.OpenGL13)
+        return;
+    glActiveTexture = (glActiveTexturePROC) extgl_GetProcAddress("glActiveTexture");
+    glClientActiveTexture = (glClientActiveTexturePROC) extgl_GetProcAddress("glClientActiveTexture");
+
+    glMultiTexCoord1d = (glMultiTexCoord1dPROC) extgl_GetProcAddress("glMultiTexCoord1d");
+    glMultiTexCoord1dv = (glMultiTexCoord1dvPROC) extgl_GetProcAddress("glMultiTexCoord1dv");
+    glMultiTexCoord1f = (glMultiTexCoord1fPROC) extgl_GetProcAddress("glMultiTexCoord1f");
+    glMultiTexCoord1fv = (glMultiTexCoord1fvPROC) extgl_GetProcAddress("glMultiTexCoord1fv");
+    glMultiTexCoord1i = (glMultiTexCoord1iPROC) extgl_GetProcAddress("glMultiTexCoord1i");
+    glMultiTexCoord1iv = (glMultiTexCoord1ivPROC) extgl_GetProcAddress("glMultiTexCoord1iv");
+    glMultiTexCoord1s = (glMultiTexCoord1sPROC) extgl_GetProcAddress("glMultiTexCoord1s");
+    glMultiTexCoord1sv = (glMultiTexCoord1svPROC) extgl_GetProcAddress("glMultiTexCoord1sv");
+
+    glMultiTexCoord2d = (glMultiTexCoord2dPROC) extgl_GetProcAddress("glMultiTexCoord2d");
+    glMultiTexCoord2dv = (glMultiTexCoord2dvPROC) extgl_GetProcAddress("glMultiTexCoord2dv");
+    glMultiTexCoord2f = (glMultiTexCoord2fPROC) extgl_GetProcAddress("glMultiTexCoord2f");
+    glMultiTexCoord2fv = (glMultiTexCoord2fvPROC) extgl_GetProcAddress("glMultiTexCoord2fv");
+    glMultiTexCoord2i = (glMultiTexCoord2iPROC) extgl_GetProcAddress("glMultiTexCoord2i");
+    glMultiTexCoord2iv = (glMultiTexCoord2ivPROC) extgl_GetProcAddress("glMultiTexCoord2iv");
+    glMultiTexCoord2s = (glMultiTexCoord2sPROC) extgl_GetProcAddress("glMultiTexCoord2s");
+    glMultiTexCoord2sv = (glMultiTexCoord2svPROC) extgl_GetProcAddress("glMultiTexCoord2sv");
+
+    glMultiTexCoord3d = (glMultiTexCoord3dPROC) extgl_GetProcAddress("glMultiTexCoord3d");
+    glMultiTexCoord3dv = (glMultiTexCoord3dvPROC) extgl_GetProcAddress("glMultiTexCoord3dv");
+    glMultiTexCoord3f = (glMultiTexCoord3fPROC) extgl_GetProcAddress("glMultiTexCoord3f");
+    glMultiTexCoord3fv = (glMultiTexCoord3fvPROC) extgl_GetProcAddress("glMultiTexCoord3fv");
+    glMultiTexCoord3i = (glMultiTexCoord3iPROC) extgl_GetProcAddress("glMultiTexCoord3i");
+    glMultiTexCoord3iv = (glMultiTexCoord3ivPROC) extgl_GetProcAddress("glMultiTexCoord3iv");
+    glMultiTexCoord3s = (glMultiTexCoord3sPROC) extgl_GetProcAddress("glMultiTexCoord3s");
+    glMultiTexCoord3sv = (glMultiTexCoord3svPROC) extgl_GetProcAddress("glMultiTexCoord3sv");
+
+    glMultiTexCoord4d = (glMultiTexCoord4dPROC) extgl_GetProcAddress("glMultiTexCoord4d");
+    glMultiTexCoord4dv = (glMultiTexCoord4dvPROC) extgl_GetProcAddress("glMultiTexCoord4dv");
+    glMultiTexCoord4f = (glMultiTexCoord4fPROC) extgl_GetProcAddress("glMultiTexCoord4f");
+    glMultiTexCoord4fv = (glMultiTexCoord4fvPROC) extgl_GetProcAddress("glMultiTexCoord4fv");
+    glMultiTexCoord4i = (glMultiTexCoord4iPROC) extgl_GetProcAddress("glMultiTexCoord4i");
+    glMultiTexCoord4iv = (glMultiTexCoord4ivPROC) extgl_GetProcAddress("glMultiTexCoord4iv");
+    glMultiTexCoord4s = (glMultiTexCoord4sPROC) extgl_GetProcAddress("glMultiTexCoord4s");
+    glMultiTexCoord4sv = (glMultiTexCoord4svPROC) extgl_GetProcAddress("glMultiTexCoord4sv");
+
+    glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC) extgl_GetProcAddress("glLoadTransposeMatrixf");
+    glLoadTransposeMatrixd = (glLoadTransposeMatrixdPROC) extgl_GetProcAddress("glLoadTransposeMatrixd");
+    glMultTransposeMatrixf = (glMultTransposeMatrixfPROC) extgl_GetProcAddress("glMultTransposeMatrixf");
+    glMultTransposeMatrixd = (glMultTransposeMatrixdPROC) extgl_GetProcAddress("glMultTransposeMatrixd");
+    glCompressedTexImage3D = (glCompressedTexImage3DPROC) extgl_GetProcAddress("glCompressedTexImage3D");
+    glCompressedTexImage2D = (glCompressedTexImage2DPROC) extgl_GetProcAddress("glCompressedTexImage2D");
+    glCompressedTexImage1D = (glCompressedTexImage1DPROC) extgl_GetProcAddress("glCompressedTexImage1D");
+    glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC) extgl_GetProcAddress("glCompressedTexSubImage3D");
+    glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC) extgl_GetProcAddress("glCompressedTexSubImage2D");
+    glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC) extgl_GetProcAddress("glCompressedTexSubImage1D");
+    glGetCompressedTexImage = (glGetCompressedTexImagePROC) extgl_GetProcAddress("glGetCompressedTexImage");
+
+    glSampleCoverage = (glSampleCoveragePROC) extgl_GetProcAddress("glSampleCoverage");
+#endif /* GL_VERSION_1_3 */
+#endif /* WIN32 */
+}
+
+void extgl_InitOpenGL1_4()
+{
+#ifdef _WIN32
+#ifdef GL_VERSION_1_4
+    if (!extgl_Extensions.OpenGL14)
+        return;
+    glBlendColor = (glBlendColorPROC) extgl_GetProcAddress("glBlendColor");
+    glBlendEquation = (glBlendEquationPROC) extgl_GetProcAddress("glBlendEquation");
+    glFogCoordf = (glFogCoordfPROC) extgl_GetProcAddress("glFogCoordf");
+    glFogCoordfv = (glFogCoordfvPROC) extgl_GetProcAddress("glFogCoordfv");
+    glFogCoordd = (glFogCoorddPROC) extgl_GetProcAddress("glFogCoordd");
+    glFogCoorddv = (glFogCoorddvPROC) extgl_GetProcAddress("glFogCoorddv");
+    glFogCoordPointer = (glFogCoordPointerPROC) extgl_GetProcAddress("glFogCoordPointer");
+    glMultiDrawArrays = (glMultiDrawArraysPROC) extgl_GetProcAddress("glMultiDrawArrays");
+    glMultiDrawElements = (glMultiDrawElementsPROC) extgl_GetProcAddress("glMultiDrawElements");
+    glPointParameterf = (glPointParameterfPROC) extgl_GetProcAddress("glPointParameterf");
+    glPointParameterfv = (glPointParameterfvPROC) extgl_GetProcAddress("glPointParameterfv");
+    glSecondaryColor3b = (glSecondaryColor3bPROC) extgl_GetProcAddress("glSecondaryColor3b");
+    glSecondaryColor3bv = (glSecondaryColor3bvPROC) extgl_GetProcAddress("glSecondaryColor3bv");
+    glSecondaryColor3d = (glSecondaryColor3dPROC) extgl_GetProcAddress("glSecondaryColor3d");
+    glSecondaryColor3dv = (glSecondaryColor3dvPROC) extgl_GetProcAddress("glSecondaryColor3dv");
+    glSecondaryColor3f = (glSecondaryColor3fPROC) extgl_GetProcAddress("glSecondaryColor3f");
+    glSecondaryColor3fv = (glSecondaryColor3fvPROC) extgl_GetProcAddress("glSecondaryColor3fv");
+    glSecondaryColor3i = (glSecondaryColor3iPROC) extgl_GetProcAddress("glSecondaryColor3i");
+    glSecondaryColor3iv = (glSecondaryColor3ivPROC) extgl_GetProcAddress("glSecondaryColor3iv");
+    glSecondaryColor3s = (glSecondaryColor3sPROC) extgl_GetProcAddress("glSecondaryColor3s");
+    glSecondaryColor3sv = (glSecondaryColor3svPROC) extgl_GetProcAddress("glSecondaryColor3sv");
+    glSecondaryColor3ub = (glSecondaryColor3ubPROC) extgl_GetProcAddress("glSecondaryColor3ub");
+    glSecondaryColor3ubv = (glSecondaryColor3ubvPROC) extgl_GetProcAddress("glSecondaryColor3ubv");
+    glSecondaryColor3ui = (glSecondaryColor3uiPROC) extgl_GetProcAddress("glSecondaryColor3ui");
+    glSecondaryColor3uiv = (glSecondaryColor3uivPROC) extgl_GetProcAddress("glSecondaryColor3uiv");
+    glSecondaryColor3us = (glSecondaryColor3usPROC) extgl_GetProcAddress("glSecondaryColor3us");
+    glSecondaryColor3usv = (glSecondaryColor3usvPROC) extgl_GetProcAddress("glSecondaryColor3usv");
+    glSecondaryColorPointer = (glSecondaryColorPointerPROC) extgl_GetProcAddress("glSecondaryColorPointer");
+    glBlendFuncSeparate = (glBlendFuncSeparatePROC) extgl_GetProcAddress("glBlendFuncSeparate");
+    glWindowPos2d = (glWindowPos2dPROC) extgl_GetProcAddress("glWindowPos2d");
+    glWindowPos2f = (glWindowPos2fPROC) extgl_GetProcAddress("glWindowPos2f");
+    glWindowPos2i = (glWindowPos2iPROC) extgl_GetProcAddress("glWindowPos2i");
+    glWindowPos2s = (glWindowPos2sPROC) extgl_GetProcAddress("glWindowPos2s");
+    glWindowPos2dv = (glWindowPos2dvPROC) extgl_GetProcAddress("glWindowPos2dv");
+    glWindowPos2fv = (glWindowPos2fvPROC) extgl_GetProcAddress("glWindowPos2fv");
+    glWindowPos2iv = (glWindowPos2ivPROC) extgl_GetProcAddress("glWindowPos2iv");
+    glWindowPos2sv = (glWindowPos2svPROC) extgl_GetProcAddress("glWindowPos2sv");
+    glWindowPos3d = (glWindowPos3dPROC) extgl_GetProcAddress("glWindowPos3d");
+    glWindowPos3f = (glWindowPos3fPROC) extgl_GetProcAddress("glWindowPos3f");
+    glWindowPos3i = (glWindowPos3iPROC) extgl_GetProcAddress("glWindowPos3i");
+    glWindowPos3s = (glWindowPos3sPROC) extgl_GetProcAddress("glWindowPos3s");
+    glWindowPos3dv = (glWindowPos3dvPROC) extgl_GetProcAddress("glWindowPos3dv");
+    glWindowPos3fv = (glWindowPos3fvPROC) extgl_GetProcAddress("glWindowPos3fv");
+    glWindowPos3iv = (glWindowPos3ivPROC) extgl_GetProcAddress("glWindowPos3iv");
+    glWindowPos3sv = (glWindowPos3svPROC) extgl_GetProcAddress("glWindowPos3sv");
+#endif /* GL_VERSION_1_4 */
+#endif /* WIN32 */
+}
+
+void extgl_InitSupportedExtensions()
+{
+    char *s = (char*) glGetString(GL_VERSION);
+    if (!s)
+        return;
+    const char v[2]={s[0],'\0'};
+    int major = atoi(v);
+    if(atoi(v) >= 2){
+      extgl_Extensions.OpenGL12 = 1;
+      extgl_Extensions.OpenGL13 = 1;
+      extgl_Extensions.OpenGL14 = 1;
+    }else{
+    s = strstr(s, "1.");
+    }
+    if (s == NULL)
+    {
+        extgl_Extensions.OpenGL12 = 0;    
+        extgl_Extensions.OpenGL13 = 0;    
+        extgl_Extensions.OpenGL14 = 0;
+    }
+    else
+    {
+        extgl_Extensions.OpenGL12 = 0;
+        extgl_Extensions.OpenGL13 = 0;
+        extgl_Extensions.OpenGL14 = 0;
+
+        if( s[2] >= '4' )
+        {
+            extgl_Extensions.OpenGL12 = 1;
+            extgl_Extensions.OpenGL13 = 1;
+            extgl_Extensions.OpenGL14 = 1;
+        }
+        if( s[2] == '3' )
+        {
+            extgl_Extensions.OpenGL12 = 1;
+            extgl_Extensions.OpenGL13 = 1;
+        }
+        if( s[2] == '2' )
+        {
+            extgl_Extensions.OpenGL12 = 1;
+        }
+    }
+    extgl_Extensions.ARB_depth_texture = QueryExtension("GL_ARB_depth_texture");
+    extgl_Extensions.ARB_fragment_program = QueryExtension("GL_ARB_fragment_program");
+    extgl_Extensions.ARB_imaging = QueryExtension("GL_ARB_imaging");
+    extgl_Extensions.ARB_matrix_palette = QueryExtension("GL_ARB_matrix_palette");
+    extgl_Extensions.ARB_multisample = QueryExtension("GL_ARB_multisample");
+    extgl_Extensions.ARB_multitexture = QueryExtension("GL_ARB_multitexture");
+    extgl_Extensions.ARB_point_parameters = QueryExtension("GL_ARB_point_parameters");
+    extgl_Extensions.ARB_shadow = QueryExtension("GL_ARB_shadow");
+    extgl_Extensions.ARB_shadow_ambient = QueryExtension("GL_ARB_shadow_ambient");
+    extgl_Extensions.ARB_texture_border_clamp = QueryExtension("GL_ARB_texture_border_clamp");
+    extgl_Extensions.ARB_texture_compression = QueryExtension("GL_ARB_texture_compression");
+    extgl_Extensions.ARB_texture_cube_map = QueryExtension("GL_ARB_texture_cube_map");
+    extgl_Extensions.ARB_texture_env_add = QueryExtension("GL_ARB_texture_env_add");
+    extgl_Extensions.ARB_texture_env_combine = QueryExtension("GL_ARB_texture_env_combine");
+    extgl_Extensions.ARB_texture_env_crossbar = QueryExtension("GL_ARB_texture_env_crossbar");
+    extgl_Extensions.ARB_texture_env_dot3 = QueryExtension("GL_ARB_texture_env_dot3");
+    extgl_Extensions.ARB_texture_mirrored_repeat = QueryExtension("GL_ARB_texture_mirrored_repeat");
+    extgl_Extensions.ARB_transpose_matrix = QueryExtension("GL_ARB_transpose_matrix");
+    extgl_Extensions.ARB_vertex_blend = QueryExtension("GL_ARB_vertex_blend");
+    extgl_Extensions.ARB_vertex_program = QueryExtension("GL_ARB_vertex_program");
+    extgl_Extensions.ARB_window_pos = QueryExtension("GL_ARB_window_pos");
+    extgl_Extensions.EXT_abgr = QueryExtension("GL_EXT_abgr");
+    extgl_Extensions.EXT_bgra = QueryExtension("GL_EXT_bgra");
+    extgl_Extensions.EXT_blend_func_separate = QueryExtension("GL_EXT_blend_function_separate");
+    extgl_Extensions.EXT_compiled_vertex_array = QueryExtension("GL_EXT_compiled_vertex_array");
+    extgl_Extensions.EXT_cull_vertex = QueryExtension("GL_EXT_cull_vertex");
+    extgl_Extensions.EXT_draw_range_elements = QueryExtension("GL_EXT_draw_range_elements");
+    extgl_Extensions.EXT_fog_coord = QueryExtension("GL_EXT_fog_coord");
+    extgl_Extensions.EXT_multi_draw_arrays = QueryExtension("GL_EXT_multi_draw_arrays");
+    extgl_Extensions.EXT_point_parameters = QueryExtension("GL_EXT_point_parameters");
+    extgl_Extensions.EXT_secondary_color = QueryExtension("GL_EXT_secondary_color");
+    extgl_Extensions.EXT_separate_specular_color = QueryExtension("GL_EXT_separate_specular_color");
+    extgl_Extensions.EXT_shadow_funcs = QueryExtension("GL_EXT_shadow_funcs");
+    extgl_Extensions.EXT_stencil_two_side = QueryExtension("GL_EXT_stencil_two_side");
+    extgl_Extensions.EXT_stencil_wrap = QueryExtension("GL_EXT_stencil_wrap");
+    extgl_Extensions.EXT_texture_compression_s3tc = QueryExtension("GL_EXT_texture_compression_s3tc");
+    extgl_Extensions.EXT_texture_env_combine = QueryExtension("GL_EXT_texture_env_combine");
+    extgl_Extensions.EXT_texture_filter_anisotropic = QueryExtension("GL_EXT_texture_filter_anisotropic");
+    extgl_Extensions.EXT_texture_lod_bias = QueryExtension("GL_EXT_texture_lod_bias");
+    extgl_Extensions.EXT_texture_rectangle = QueryExtension("GL_EXT_texture_rectangle"); // added -ec
+    extgl_Extensions.EXT_vertex_shader = QueryExtension("GL_EXT_vertex_shader");
+    extgl_Extensions.EXT_vertex_weighting = QueryExtension("GL_EXT_vertex_weighting");
+    extgl_Extensions.ATI_draw_buffers = QueryExtension("GL_ATI_draw_buffers"); // added -ec    
+    extgl_Extensions.ATI_element_array = QueryExtension("GL_ATI_element_array");
+    extgl_Extensions.ATI_envmap_bumpmap = QueryExtension("GL_ATI_envmap_bumpmap");
+    extgl_Extensions.ATI_fragment_shader = QueryExtension("GL_ATI_fragment_shader");
+    extgl_Extensions.ATI_pn_triangles = QueryExtension("GL_ATI_pn_triangles");
+    extgl_Extensions.ATI_point_cull_mode = QueryExtension("GL_ATI_point_cull_mode");
+    extgl_Extensions.ATI_text_fragment_shader = QueryExtension("GL_ATI_text_fragment_shader");
+    extgl_Extensions.ATI_texture_float = QueryExtension("GL_ATI_texture_float"); // added -ec
+    extgl_Extensions.ATI_texture_mirror_once = QueryExtension("GL_ATI_texture_mirror_once");
+    extgl_Extensions.ATI_vertex_array_object = QueryExtension("GL_ATI_vertex_array_object");
+    extgl_Extensions.ATI_vertex_streams = QueryExtension("GL_ATI_vertex_streams");
+    extgl_Extensions.ATIX_point_sprites = QueryExtension("GL_ATIX_point_sprites");
+    extgl_Extensions.ATIX_texture_env_route = QueryExtension("GL_ATIX_texture_env_route");
+    extgl_Extensions.HP_occlusion_test = QueryExtension("GL_HP_occlusion_test");
+    extgl_Extensions.NV_blend_square = QueryExtension("GL_NV_blend_square");
+    extgl_Extensions.NV_copy_depth_to_color = QueryExtension("GL_NV_copy_depth_to_color");
+    extgl_Extensions.NV_depth_clamp = QueryExtension("GL_NV_depth_clamp");
+    extgl_Extensions.NV_element_array = QueryExtension("GL_NV_element_array");
+    extgl_Extensions.NV_evaluators = QueryExtension("GL_NV_evaluators");
+    extgl_Extensions.NV_fence = QueryExtension("GL_NV_fence");
+    extgl_Extensions.NV_float_buffer = QueryExtension("GL_NV_float_buffer");
+    extgl_Extensions.NV_fog_distance = QueryExtension("GL_NV_fog_distance");
+    extgl_Extensions.NV_fragment_program = QueryExtension("GL_NV_fragment_program");
+    extgl_Extensions.NV_light_max_exponent = QueryExtension("GL_NV_light_max_exponent");
+    extgl_Extensions.NV_occlusion_query = QueryExtension("GL_NV_occlusion_query");
+    extgl_Extensions.NV_packed_depth_stencil = QueryExtension("GL_NV_packed_depth_stencil");
+    extgl_Extensions.NV_point_sprite = QueryExtension("GL_NV_point_sprite");
+    extgl_Extensions.NV_primitive_restart = QueryExtension("GL_NV_primitive_restart");
+    extgl_Extensions.NV_register_combiners = QueryExtension("GL_NV_register_combiners");
+    extgl_Extensions.NV_register_combiners2 = QueryExtension("GL_NV_register_combiners2");
+    extgl_Extensions.NV_texgen_reflection = QueryExtension("GL_NV_texgen_reflection");
+    extgl_Extensions.NV_texture_env_combine4 = QueryExtension("GL_NV_texture_env_combine4");
+    extgl_Extensions.NV_texture_rectangle = QueryExtension("GL_NV_texture_rectangle");
+    extgl_Extensions.NV_texture_shader = QueryExtension("GL_NV_texture_shader");
+    extgl_Extensions.NV_texture_shader2 = QueryExtension("GL_NV_texture_shader2");
+    extgl_Extensions.NV_texture_shader3 = QueryExtension("GL_NV_texture_shader3");
+    extgl_Extensions.NV_vertex_array_range = QueryExtension("GL_NV_vertex_array_range");
+    extgl_Extensions.NV_vertex_array_range2 = QueryExtension("GL_NV_vertex_array_range2");
+    extgl_Extensions.NV_vertex_program = QueryExtension("GL_NV_vertex_program");
+    extgl_Extensions.NV_vertex_program1_1 = QueryExtension("GL_NV_vertex_program1_1");
+    extgl_Extensions.NV_vertex_program2 = QueryExtension("GL_NV_vertex_program2");
+    extgl_Extensions.SGIS_generate_mipmap = QueryExtension("GL_SGIS_generate_mipmap");
+    extgl_Extensions.SGIX_depth_texture = QueryExtension("GL_SGIX_depth_texture");
+    extgl_Extensions.SGIX_shadow = QueryExtension("GL_SGIX_shadow");
+}
+
+
+/* extgl_Init the extensions and load all the functions */
+int extgl_Initialize()
+{
+    extgl_error = 0;
+    extgl_InitSupportedExtensions();
+    
+    /* first load the etensions */
+    extgl_InitARBTransposeMatrix();
+    extgl_InitARBMultisample();
+    extgl_InitEXTCompiledVertexArray();
+    extgl_InitEXTSecondaryColor();
+    extgl_InitEXTFogCoord();
+    extgl_InitNVVertexArrayRange();
+    extgl_InitEXTPointParameters();
+    extgl_InitNVRegisterCombiners();
+    extgl_InitEXTVertexWeighting();
+    extgl_InitNVVertexProgram();
+    extgl_InitNVFence();
+    extgl_InitNVRegisterCombiners2();
+    extgl_InitATIPNTriangles();
+    extgl_InitARBPointParameters();
+    extgl_InitARBVertexBlend();
+    extgl_InitEXTMultiDrawArrays();
+    extgl_InitARBMatrixPalette();
+    extgl_InitEXTVertexShader();
+    extgl_InitATIEnvmapBumpmap();
+    extgl_InitATIFragmentShader();
+    extgl_InitATIElementArray();
+    extgl_InitATIVertexStreams();
+    extgl_InitATIVertexArrayObject();
+    extgl_InitNVOcclusionQuery();
+    extgl_InitNVPointSprite();
+    extgl_InitARBWindowPos();
+    extgl_InitARBTextureCompression();
+    extgl_InitEXTDrawRangeElements();
+    extgl_InitEXTStencilTwoSide();
+    extgl_InitARBVertexProgram();
+    extgl_InitEXTCullVertex();
+    extgl_InitEXTBlendFuncSeparate();
+    extgl_InitARBImaging();
+    extgl_InitARBMultitexture();
+    extgl_InitNVElementArray();
+    extgl_InitNVFragmentProgram();
+    extgl_InitNVPrimitiveRestart();
+    extgl_InitARBFragmentProgram();
+    extgl_InitATIDrawBuffers();
+    
+   /* now load core opengl */
+    extgl_InitOpenGL1_2();
+    extgl_InitOpenGL1_3();
+    extgl_InitOpenGL1_4();
+
+    /* load WGL extensions */
+#ifdef _WIN32
+    extgl_InitializeWGL();
+#endif
+
+    SupportedExtensions = extgl_Extensions;
+    return extgl_error;
+}
+
+/* deprecated function please do not use it, use extgl_Initialize() instead */
+int glInitialize()
+{
+    return extgl_Initialize();
+}
+
+/* turn on the warning for the borland compiler*/
+#ifdef __BORLANDC__
+#pragma warn .8064
+#pragma warn .8065
+#endif /* __BORLANDC__	*/
diff --git a/source/blender/freestyle/intern/rendering/extgl.h b/source/blender/freestyle/intern/rendering/extgl.h
new file mode 100755
index 00000000000..68c13dea3d2
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/extgl.h
@@ -0,0 +1,5106 @@
+/* Small parts were taken from glext.h, here's the lisence: */
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*  Most parts copyright (c) 2001-2002 Lev Povalahev under this lisence: */
+
+/* ----------------------------------------------------------------------------
+Copyright (c) 2002, Lev Povalahev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, 
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, 
+      this list of conditions and the following disclaimer in the documentation 
+      and/or other materials provided with the distribution.
+    * The name of the author may be used to endorse or promote products 
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+THE POSSIBILITY OF SUCH DAMAGE.
+------------------------------------------------------------------------------*/
+/*
+    GL_draw_range_elements support added by Benjamin Karaban
+  
+    Lev Povalahev contact information:
+    
+    levp@gmx.net
+
+    http://www.uni-karlsruhe.de/~uli2/
+*/
+/* These extensions are supported:                
+GL_ARB_depth_texture
+GL_ARB_fragment_program
+GL_ARB_imaging
+GL_ARB_matrix_palette
+GL_ARB_multisample
+GL_ARB_multitexture
+GL_ARB_point_parameters
+GL_ARB_shadow
+GL_ARB_shadow_ambient
+GL_ARB_texture_compression
+GL_ARB_texture_env_add
+GL_ARB_texture_env_dot3
+GL_ARB_texture_env_combine
+GL_ARB_texture_env_crossbar
+GL_ARB_texture_border_clamp
+GL_ARB_texture_cube_map
+GL_ARB_texture_mirrored_repeat
+GL_ARB_transpose_matrix
+GL_ARB_vertex_blend
+GL_ARB_vertex_program
+GL_ARB_window_pos
+GL_EXT_abgr
+GL_EXT_bgra
+GL_EXT_blend_function_separate
+GL_EXT_compiled_vertex_array
+GL_EXT_cull_vertex
+GL_EXT_draw_range_elements
+GL_EXT_fog_coord
+GL_EXT_multi_draw_arrays
+GL_EXT_point_parameters
+GL_EXT_secondary_color  
+GL_EXT_separate_specular_color
+GL_EXT_shadow_funcs
+GL_EXT_stencil_two_side
+GL_EXT_stencil_wrap
+GL_EXT_texture_compression_s3tc
+GL_EXT_texture_filter_anisotropic
+GL_EXT_texture_lod_bias
+GL_EXT_vertex_shader
+GL_EXT_vertex_weighting
+GL_ATI_element_array
+GL_ATI_envmap_bumpmap
+GL_ATI_fragment_shader
+GL_ATI_pn_triangles
+GL_ATI_text_fragment_shader
+GL_ATI_texture_mirror_once
+GL_ATI_vertex_array_object;
+GL_ATI_vertex_streams
+GL_ATIX_point_sprites
+GL_ATIX_texture_env_route
+GL_HP_occlusion_test
+GL_NV_blend_square
+GL_NV_copy_depth_to_color
+GL_NV_depth_clamp
+GL_NV_element_array
+GL_NV_evaluators
+GL_NV_fence
+GL_NV_float_buffer
+GL_NV_fog_distance
+GL_NV_fragment_program
+GL_NV_light_max_exponent
+GL_NV_occlusion_query
+GL_NV_packed_depth_stencil
+GL_NV_point_sprite
+GL_NV_primitive_restart
+GL_NV_register_combiners
+GL_NV_register_combiners2
+GL_NV_texgen_reflection
+GL_NV_texture_env_combine4
+GL_NV_texture_rectangle
+GL_NV_texture_shader
+GL_NV_texture_shader2
+GL_NV_texture_shader3
+GL_NV_vertex_array_range
+GL_NV_vertex_array_range2
+GL_NV_vertex_program
+GL_NV_vertex_program1_1
+GL_NV_vertex_program2
+GL_SGIS_generate_mipmap
+GL_SGIX_shadow
+GL_SGIX_depth_texture
+WGL_ARB_buffer_region
+WGL_ARB_extensions_string
+WGL_ARB_make_current_read;
+WGL_ARB_multisample
+WGL_ARB_pbuffer
+WGL_ARB_pixel_format
+WGL_ARB_render_texture 
+WGL_EXT_extensions_string
+WGL_EXT_swap_control
+WGL_NV_render_depth_texture
+WGL_NV_render_texture_rectangle
+
+// Added -ec.  Some of these are still proprietary, so do not
+// distribute.
+
+EXT_texture_rectangle
+ATI_draw_buffers
+ATI_pixel_format_float
+ATI_texture_float
+*/
+#ifndef __EXTGL_H__
+#define __EXTGL_H__
+
+#include "../system/FreestyleConfig.h"
+
+#if defined(_WIN32) && !defined(APIENTRY)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#define __glext_h_
+#define __GLEXT_H_
+#define __gl_h_
+#define __GL_H__
+
+#include <string.h>
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+#ifndef _WIN32
+#define GLAPI extern
+#define GLAPIENTRY
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef __MACH__
+/* OpenGL 1.1 definition */
+
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void GLvoid;
+
+#endif
+
+#ifndef _WIN32
+#ifndef __MACH__
+#include <GL/glx.h>
+#endif
+#endif /* _WIN32 */
+
+/* for mingw compatibility */
+typedef void (*_GLfuncptr)();
+
+#define GL_VERSION_1_1                                          1
+#define GL_ACCUM                                                0x0100
+#define GL_LOAD                                                 0x0101
+#define GL_RETURN                                               0x0102
+#define GL_MULT                                                 0x0103
+#define GL_ADD                                                  0x0104
+#define GL_NEVER                                                0x0200
+#define GL_LESS                                                 0x0201
+#define GL_EQUAL                                                0x0202
+#define GL_LEQUAL                                               0x0203
+#define GL_GREATER                                              0x0204
+#define GL_NOTEQUAL                                             0x0205
+#define GL_GEQUAL                                               0x0206
+#define GL_ALWAYS                                               0x0207
+#define GL_CURRENT_BIT                                          0x00000001
+#define GL_POINT_BIT                                            0x00000002
+#define GL_LINE_BIT                                             0x00000004
+#define GL_POLYGON_BIT                                          0x00000008
+#define GL_POLYGON_STIPPLE_BIT                                  0x00000010
+#define GL_PIXEL_MODE_BIT                                       0x00000020
+#define GL_LIGHTING_BIT                                         0x00000040
+#define GL_FOG_BIT                                              0x00000080
+#define GL_DEPTH_BUFFER_BIT                                     0x00000100
+#define GL_ACCUM_BUFFER_BIT                                     0x00000200
+#define GL_STENCIL_BUFFER_BIT                                   0x00000400
+#define GL_VIEWPORT_BIT                                         0x00000800
+#define GL_TRANSFORM_BIT                                        0x00001000
+#define GL_ENABLE_BIT                                           0x00002000
+#define GL_COLOR_BUFFER_BIT                                     0x00004000
+#define GL_HINT_BIT                                             0x00008000
+#define GL_EVAL_BIT                                             0x00010000
+#define GL_LIST_BIT                                             0x00020000
+#define GL_TEXTURE_BIT                                          0x00040000
+#define GL_SCISSOR_BIT                                          0x00080000
+#define GL_ALL_ATTRIB_BITS                                      0x000fffff
+#define GL_POINTS                                               0x0000
+#define GL_LINES                                                0x0001
+#define GL_LINE_LOOP                                            0x0002
+#define GL_LINE_STRIP                                           0x0003
+#define GL_TRIANGLES                                            0x0004
+#define GL_TRIANGLE_STRIP                                       0x0005
+#define GL_TRIANGLE_FAN                                         0x0006
+#define GL_QUADS                                                0x0007
+#define GL_QUAD_STRIP                                           0x0008
+#define GL_POLYGON                                              0x0009
+#define GL_ZERO                                                 0
+#define GL_ONE                                                  1
+#define GL_SRC_COLOR                                            0x0300
+#define GL_ONE_MINUS_SRC_COLOR                                  0x0301
+#define GL_SRC_ALPHA                                            0x0302
+#define GL_ONE_MINUS_SRC_ALPHA                                  0x0303
+#define GL_DST_ALPHA                                            0x0304
+#define GL_ONE_MINUS_DST_ALPHA                                  0x0305
+#define GL_DST_COLOR                                            0x0306
+#define GL_ONE_MINUS_DST_COLOR                                  0x0307
+#define GL_SRC_ALPHA_SATURATE                                   0x0308
+#define GL_TRUE                                                 1
+#define GL_FALSE                                                0
+#define GL_CLIP_PLANE0                                          0x3000
+#define GL_CLIP_PLANE1                                          0x3001
+#define GL_CLIP_PLANE2                                          0x3002
+#define GL_CLIP_PLANE3                                          0x3003
+#define GL_CLIP_PLANE4                                          0x3004
+#define GL_CLIP_PLANE5                                          0x3005
+#define GL_BYTE                                                 0x1400
+#define GL_UNSIGNED_BYTE                                        0x1401
+#define GL_SHORT                                                0x1402
+#define GL_UNSIGNED_SHORT                                       0x1403
+#define GL_INT                                                  0x1404
+#define GL_UNSIGNED_INT                                         0x1405
+#define GL_FLOAT                                                0x1406
+#define GL_2_BYTES                                              0x1407
+#define GL_3_BYTES                                              0x1408
+#define GL_4_BYTES                                              0x1409
+#define GL_DOUBLE                                               0x140A
+#define GL_NONE                           0
+#define GL_FRONT_LEFT                                           0x0400
+#define GL_FRONT_RIGHT                                          0x0401
+#define GL_BACK_LEFT                                            0x0402
+#define GL_BACK_RIGHT                                           0x0403
+#define GL_FRONT                                                0x0404
+#define GL_BACK                                                 0x0405
+#define GL_LEFT                                                 0x0406
+#define GL_RIGHT                                                0x0407
+#define GL_FRONT_AND_BACK                                       0x0408
+#define GL_AUX0                                                 0x0409
+#define GL_AUX1                                                 0x040A
+#define GL_AUX2                                                 0x040B
+#define GL_AUX3                                                 0x040C
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                                         0x0500
+#define GL_INVALID_VALUE                                        0x0501
+#define GL_INVALID_OPERATION                                    0x0502
+#define GL_STACK_OVERFLOW                                       0x0503
+#define GL_STACK_UNDERFLOW                                      0x0504
+#define GL_OUT_OF_MEMORY                                        0x0505
+#define GL_2D                                                   0x0600
+#define GL_3D                                                   0x0601
+#define GL_3D_COLOR                                             0x0602
+#define GL_3D_COLOR_TEXTURE                                     0x0603
+#define GL_4D_COLOR_TEXTURE                                     0x0604
+#define GL_PASS_THROUGH_TOKEN                                   0x0700
+#define GL_POINT_TOKEN                                          0x0701
+#define GL_LINE_TOKEN                                           0x0702
+#define GL_POLYGON_TOKEN                                        0x0703
+#define GL_BITMAP_TOKEN                                         0x0704
+#define GL_DRAW_PIXEL_TOKEN                                     0x0705
+#define GL_COPY_PIXEL_TOKEN                                     0x0706
+#define GL_LINE_RESET_TOKEN                                     0x0707
+#define GL_EXP                                                  0x0800
+#define GL_EXP2                                                 0x0801
+#define GL_CW                                                   0x0900
+#define GL_CCW                                                  0x0901
+#define GL_COEFF                                                0x0A00
+#define GL_ORDER                                                0x0A01
+#define GL_DOMAIN                                               0x0A02
+#define GL_CURRENT_COLOR                                        0x0B00
+#define GL_CURRENT_INDEX                                        0x0B01
+#define GL_CURRENT_NORMAL                                       0x0B02
+#define GL_CURRENT_TEXTURE_COORDS                               0x0B03
+#define GL_CURRENT_RASTER_COLOR                                 0x0B04
+#define GL_CURRENT_RASTER_INDEX                                 0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS                        0x0B06
+#define GL_CURRENT_RASTER_POSITION                              0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID                        0x0B08
+#define GL_CURRENT_RASTER_DISTANCE                              0x0B09
+#define GL_POINT_SMOOTH                                         0x0B10
+#define GL_POINT_SIZE                                           0x0B11
+#define GL_POINT_SIZE_RANGE                                     0x0B12
+#define GL_POINT_SIZE_GRANULARITY                               0x0B13
+#define GL_LINE_SMOOTH                                          0x0B20
+#define GL_LINE_WIDTH                                           0x0B21
+#define GL_LINE_WIDTH_RANGE                                     0x0B22
+#define GL_LINE_WIDTH_GRANULARITY                               0x0B23
+#define GL_LINE_STIPPLE                                         0x0B24
+#define GL_LINE_STIPPLE_PATTERN                                 0x0B25
+#define GL_LINE_STIPPLE_REPEAT                                  0x0B26
+#define GL_LIST_MODE                                            0x0B30
+#define GL_MAX_LIST_NESTING                                     0x0B31
+#define GL_LIST_BASE                                            0x0B32
+#define GL_LIST_INDEX                                           0x0B33
+#define GL_POLYGON_MODE                                         0x0B40
+#define GL_POLYGON_SMOOTH                                       0x0B41
+#define GL_POLYGON_STIPPLE                                      0x0B42
+#define GL_EDGE_FLAG                                            0x0B43
+#define GL_CULL_FACE                                            0x0B44
+#define GL_CULL_FACE_MODE                                       0x0B45
+#define GL_FRONT_FACE                                           0x0B46
+#define GL_LIGHTING                                             0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER                             0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE                                 0x0B52
+#define GL_LIGHT_MODEL_AMBIENT                                  0x0B53
+#define GL_SHADE_MODEL                                          0x0B54
+#define GL_COLOR_MATERIAL_FACE                                  0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER                             0x0B56
+#define GL_COLOR_MATERIAL                                       0x0B57
+#define GL_FOG                                                  0x0B60
+#define GL_FOG_INDEX                                            0x0B61
+#define GL_FOG_DENSITY                                          0x0B62
+#define GL_FOG_START                                            0x0B63
+#define GL_FOG_END                                              0x0B64
+#define GL_FOG_MODE                                             0x0B65
+#define GL_FOG_COLOR                                            0x0B66
+#define GL_DEPTH_RANGE                                          0x0B70
+#define GL_DEPTH_TEST                                           0x0B71
+#define GL_DEPTH_WRITEMASK                                      0x0B72
+#define GL_DEPTH_CLEAR_VALUE                                    0x0B73
+#define GL_DEPTH_FUNC                                           0x0B74
+#define GL_ACCUM_CLEAR_VALUE                                    0x0B80
+#define GL_STENCIL_TEST                                         0x0B90
+#define GL_STENCIL_CLEAR_VALUE                                  0x0B91
+#define GL_STENCIL_FUNC                                         0x0B92
+#define GL_STENCIL_VALUE_MASK                                   0x0B93
+#define GL_STENCIL_FAIL                                         0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL                              0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS                              0x0B96
+#define GL_STENCIL_REF                                          0x0B97
+#define GL_STENCIL_WRITEMASK                                    0x0B98
+#define GL_MATRIX_MODE                                          0x0BA0
+#define GL_NORMALIZE                                            0x0BA1
+#define GL_VIEWPORT                                             0x0BA2
+#define GL_MODELVIEW_STACK_DEPTH                                0x0BA3
+#define GL_PROJECTION_STACK_DEPTH                               0x0BA4
+#define GL_TEXTURE_STACK_DEPTH                                  0x0BA5
+#define GL_MODELVIEW_MATRIX                                     0x0BA6
+#define GL_PROJECTION_MATRIX                                    0x0BA7
+#define GL_TEXTURE_MATRIX                                       0x0BA8
+#define GL_ATTRIB_STACK_DEPTH                                   0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH                            0x0BB1
+#define GL_ALPHA_TEST                                           0x0BC0
+#define GL_ALPHA_TEST_FUNC                                      0x0BC1
+#define GL_ALPHA_TEST_REF                                       0x0BC2
+#define GL_DITHER                                               0x0BD0
+#define GL_BLEND_DST                                            0x0BE0
+#define GL_BLEND_SRC                                            0x0BE1
+#define GL_BLEND                                                0x0BE2
+#define GL_LOGIC_OP_MODE                                        0x0BF0
+#define GL_INDEX_LOGIC_OP                                       0x0BF1
+#define GL_COLOR_LOGIC_OP                                       0x0BF2
+#define GL_AUX_BUFFERS                                          0x0C00
+#define GL_DRAW_BUFFER                                          0x0C01
+#define GL_READ_BUFFER                                          0x0C02
+#define GL_SCISSOR_BOX                                          0x0C10
+#define GL_SCISSOR_TEST                                         0x0C11
+#define GL_INDEX_CLEAR_VALUE                                    0x0C20
+#define GL_INDEX_WRITEMASK                                      0x0C21
+#define GL_COLOR_CLEAR_VALUE                                    0x0C22
+#define GL_COLOR_WRITEMASK                                      0x0C23
+#define GL_INDEX_MODE                                           0x0C30
+#define GL_RGBA_MODE                                            0x0C31
+#define GL_DOUBLEBUFFER                                         0x0C32
+#define GL_STEREO                                               0x0C33
+#define GL_RENDER_MODE                                          0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT                          0x0C50
+#define GL_POINT_SMOOTH_HINT                                    0x0C51
+#define GL_LINE_SMOOTH_HINT                                     0x0C52
+#define GL_POLYGON_SMOOTH_HINT                                  0x0C53
+#define GL_FOG_HINT                                             0x0C54
+#define GL_TEXTURE_GEN_S                                        0x0C60
+#define GL_TEXTURE_GEN_T                                        0x0C61
+#define GL_TEXTURE_GEN_R                                        0x0C62
+#define GL_TEXTURE_GEN_Q                                        0x0C63
+#define GL_PIXEL_MAP_I_TO_I                                     0x0C70
+#define GL_PIXEL_MAP_S_TO_S                                     0x0C71
+#define GL_PIXEL_MAP_I_TO_R                                     0x0C72
+#define GL_PIXEL_MAP_I_TO_G                                     0x0C73
+#define GL_PIXEL_MAP_I_TO_B                                     0x0C74
+#define GL_PIXEL_MAP_I_TO_A                                     0x0C75
+#define GL_PIXEL_MAP_R_TO_R                                     0x0C76
+#define GL_PIXEL_MAP_G_TO_G                                     0x0C77
+#define GL_PIXEL_MAP_B_TO_B                                     0x0C78
+#define GL_PIXEL_MAP_A_TO_A                                     0x0C79
+#define GL_PIXEL_MAP_I_TO_I_SIZE                                0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE                                0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE                                0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE                                0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE                                0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE                                0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE                                0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE                                0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE                                0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE                                0x0CB9
+#define GL_UNPACK_SWAP_BYTES                                    0x0CF0
+#define GL_UNPACK_LSB_FIRST                                     0x0CF1
+#define GL_UNPACK_ROW_LENGTH                                    0x0CF2
+#define GL_UNPACK_SKIP_ROWS                                     0x0CF3
+#define GL_UNPACK_SKIP_PIXELS                                   0x0CF4
+#define GL_UNPACK_ALIGNMENT                                     0x0CF5
+#define GL_PACK_SWAP_BYTES                                      0x0D00
+#define GL_PACK_LSB_FIRST                                       0x0D01
+#define GL_PACK_ROW_LENGTH                                      0x0D02
+#define GL_PACK_SKIP_ROWS                                       0x0D03
+#define GL_PACK_SKIP_PIXELS                                     0x0D04
+#define GL_PACK_ALIGNMENT                                       0x0D05
+#define GL_MAP_COLOR                                            0x0D10
+#define GL_MAP_STENCIL                                          0x0D11
+#define GL_INDEX_SHIFT                                          0x0D12
+#define GL_INDEX_OFFSET                                         0x0D13
+#define GL_RED_SCALE                                            0x0D14
+#define GL_RED_BIAS                                             0x0D15
+#define GL_ZOOM_X                                               0x0D16
+#define GL_ZOOM_Y                                               0x0D17
+#define GL_GREEN_SCALE                                          0x0D18
+#define GL_GREEN_BIAS                                           0x0D19
+#define GL_BLUE_SCALE                                           0x0D1A
+#define GL_BLUE_BIAS                                            0x0D1B
+#define GL_ALPHA_SCALE                                          0x0D1C
+#define GL_ALPHA_BIAS                                           0x0D1D
+#define GL_DEPTH_SCALE                                          0x0D1E
+#define GL_DEPTH_BIAS                                           0x0D1F
+#define GL_MAX_EVAL_ORDER                                       0x0D30
+#define GL_MAX_LIGHTS                                           0x0D31
+#define GL_MAX_CLIP_PLANES                                      0x0D32
+#define GL_MAX_TEXTURE_SIZE                                     0x0D33
+#define GL_MAX_PIXEL_MAP_TABLE                                  0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH                               0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH                            0x0D36
+#define GL_MAX_NAME_STACK_DEPTH                                 0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH                           0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH                              0x0D39
+#define GL_MAX_VIEWPORT_DIMS                                    0x0D3A
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH                        0x0D3B
+#define GL_SUBPIXEL_BITS                                        0x0D50
+#define GL_INDEX_BITS                                           0x0D51
+#define GL_RED_BITS                                             0x0D52
+#define GL_GREEN_BITS                                           0x0D53
+#define GL_BLUE_BITS                                            0x0D54
+#define GL_ALPHA_BITS                                           0x0D55
+#define GL_DEPTH_BITS                                           0x0D56
+#define GL_STENCIL_BITS                                         0x0D57
+#define GL_ACCUM_RED_BITS                                       0x0D58
+#define GL_ACCUM_GREEN_BITS                                     0x0D59
+#define GL_ACCUM_BLUE_BITS                                      0x0D5A
+#define GL_ACCUM_ALPHA_BITS                                     0x0D5B
+#define GL_NAME_STACK_DEPTH                                     0x0D70
+#define GL_AUTO_NORMAL                                          0x0D80
+#define GL_MAP1_COLOR_4                                         0x0D90
+#define GL_MAP1_INDEX                                           0x0D91
+#define GL_MAP1_NORMAL                                          0x0D92
+#define GL_MAP1_TEXTURE_COORD_1                                 0x0D93
+#define GL_MAP1_TEXTURE_COORD_2                                 0x0D94
+#define GL_MAP1_TEXTURE_COORD_3                                 0x0D95
+#define GL_MAP1_TEXTURE_COORD_4                                 0x0D96
+#define GL_MAP1_VERTEX_3                                        0x0D97
+#define GL_MAP1_VERTEX_4                                        0x0D98
+#define GL_MAP2_COLOR_4                                         0x0DB0
+#define GL_MAP2_INDEX                                           0x0DB1
+#define GL_MAP2_NORMAL                                          0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1                                 0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2                                 0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3                                 0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4                                 0x0DB6
+#define GL_MAP2_VERTEX_3                                        0x0DB7
+#define GL_MAP2_VERTEX_4                                        0x0DB8
+#define GL_MAP1_GRID_DOMAIN                                     0x0DD0
+#define GL_MAP1_GRID_SEGMENTS                                   0x0DD1
+#define GL_MAP2_GRID_DOMAIN                                     0x0DD2
+#define GL_MAP2_GRID_SEGMENTS                                   0x0DD3
+#define GL_TEXTURE_1D                                           0x0DE0
+#define GL_TEXTURE_2D                                           0x0DE1
+#define GL_FEEDBACK_BUFFER_POINTER                              0x0DF0
+#define GL_FEEDBACK_BUFFER_SIZE                                 0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE                                 0x0DF2
+#define GL_SELECTION_BUFFER_POINTER                             0x0DF3
+#define GL_SELECTION_BUFFER_SIZE                                0x0DF4
+#define GL_TEXTURE_WIDTH                                        0x1000
+#define GL_TEXTURE_HEIGHT                                       0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT                              0x1003
+#define GL_TEXTURE_BORDER_COLOR                                 0x1004
+#define GL_TEXTURE_BORDER                                       0x1005
+#define GL_DONT_CARE                                            0x1100
+#define GL_FASTEST                                              0x1101
+#define GL_NICEST                                               0x1102
+#define GL_LIGHT0                                               0x4000
+#define GL_LIGHT1                                               0x4001
+#define GL_LIGHT2                                               0x4002
+#define GL_LIGHT3                                               0x4003
+#define GL_LIGHT4                                               0x4004
+#define GL_LIGHT5                                               0x4005
+#define GL_LIGHT6                                               0x4006
+#define GL_LIGHT7                                               0x4007
+#define GL_AMBIENT                                              0x1200
+#define GL_DIFFUSE                                              0x1201
+#define GL_SPECULAR                                             0x1202
+#define GL_POSITION                                             0x1203
+#define GL_SPOT_DIRECTION                                       0x1204
+#define GL_SPOT_EXPONENT                                        0x1205
+#define GL_SPOT_CUTOFF                                          0x1206
+#define GL_CONSTANT_ATTENUATION                                 0x1207
+#define GL_LINEAR_ATTENUATION                                   0x1208
+#define GL_QUADRATIC_ATTENUATION                                0x1209
+#define GL_COMPILE                                              0x1300
+#define GL_COMPILE_AND_EXECUTE                                  0x1301
+#define GL_CLEAR                                                0x1500
+#define GL_AND                                                  0x1501
+#define GL_AND_REVERSE                                          0x1502
+#define GL_COPY                                                 0x1503
+#define GL_AND_INVERTED                                         0x1504
+#define GL_NOOP                                                 0x1505
+#define GL_XOR                                                  0x1506
+#define GL_OR                                                   0x1507
+#define GL_NOR                                                  0x1508
+#define GL_EQUIV                                                0x1509
+#define GL_INVERT                                               0x150A
+#define GL_OR_REVERSE                                           0x150B
+#define GL_COPY_INVERTED                                        0x150C
+#define GL_OR_INVERTED                                          0x150D
+#define GL_NAND                                                 0x150E
+#define GL_SET                                                  0x150F
+#define GL_EMISSION                                             0x1600
+#define GL_SHININESS                                            0x1601
+#define GL_AMBIENT_AND_DIFFUSE                                  0x1602
+#define GL_COLOR_INDEXES                                        0x1603
+#define GL_MODELVIEW                                            0x1700
+#define GL_PROJECTION                                           0x1701
+#define GL_TEXTURE                                              0x1702
+#define GL_COLOR                                                0x1800
+#define GL_DEPTH                                                0x1801
+#define GL_STENCIL                                              0x1802
+#define GL_COLOR_INDEX                                          0x1900
+#define GL_STENCIL_INDEX                                        0x1901
+#define GL_DEPTH_COMPONENT                                      0x1902
+#define GL_RED                                                  0x1903
+#define GL_GREEN                                                0x1904
+#define GL_BLUE                                                 0x1905
+#define GL_ALPHA                                                0x1906
+#define GL_RGB                                                  0x1907
+#define GL_RGBA                                                 0x1908
+#define GL_LUMINANCE                                            0x1909
+#define GL_LUMINANCE_ALPHA                                      0x190A
+#define GL_BITMAP                                               0x1A00
+#define GL_POINT                                                0x1B00
+#define GL_LINE                                                 0x1B01
+#define GL_FILL                                                 0x1B02
+#define GL_RENDER                                               0x1C00
+#define GL_FEEDBACK                                             0x1C01
+#define GL_SELECT                                               0x1C02
+#define GL_FLAT                                                 0x1D00
+#define GL_SMOOTH                                               0x1D01
+#define GL_KEEP                                                 0x1E00
+#define GL_REPLACE                                              0x1E01
+#define GL_INCR                                                 0x1E02
+#define GL_DECR                                                 0x1E03
+#define GL_VENDOR                                               0x1F00
+#define GL_RENDERER                                             0x1F01
+#define GL_VERSION                                              0x1F02
+#define GL_EXTENSIONS                                           0x1F03
+#define GL_S                                                    0x2000
+#define GL_T                                                    0x2001
+#define GL_R                                                    0x2002
+#define GL_Q                                                    0x2003
+#define GL_MODULATE                                             0x2100
+#define GL_DECAL                                                0x2101
+#define GL_TEXTURE_ENV_MODE                                     0x2200
+#define GL_TEXTURE_ENV_COLOR                                    0x2201
+#define GL_TEXTURE_ENV                                          0x2300
+#define GL_EYE_LINEAR                                           0x2400
+#define GL_OBJECT_LINEAR                                        0x2401
+#define GL_SPHERE_MAP                                           0x2402
+#define GL_TEXTURE_GEN_MODE                                     0x2500
+#define GL_OBJECT_PLANE                                         0x2501
+#define GL_EYE_PLANE                                            0x2502
+#define GL_NEAREST                                              0x2600
+#define GL_LINEAR                                               0x2601
+#define GL_NEAREST_MIPMAP_NEAREST                               0x2700
+#define GL_LINEAR_MIPMAP_NEAREST                                0x2701
+#define GL_NEAREST_MIPMAP_LINEAR                                0x2702
+#define GL_LINEAR_MIPMAP_LINEAR                                 0x2703
+#define GL_TEXTURE_MAG_FILTER                                   0x2800
+#define GL_TEXTURE_MIN_FILTER                                   0x2801
+#define GL_TEXTURE_WRAP_S                                       0x2802
+#define GL_TEXTURE_WRAP_T                                       0x2803
+#define GL_CLAMP                                                0x2900
+#define GL_REPEAT                                               0x2901
+#define GL_CLIENT_PIXEL_STORE_BIT                               0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT                              0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS                               0xffffffff
+#define GL_POLYGON_OFFSET_FACTOR                                0x8038
+#define GL_POLYGON_OFFSET_UNITS                                 0x2A00
+#define GL_POLYGON_OFFSET_POINT                                 0x2A01
+#define GL_POLYGON_OFFSET_LINE                                  0x2A02
+#define GL_POLYGON_OFFSET_FILL                                  0x8037
+#define GL_ALPHA4                                               0x803B
+#define GL_ALPHA8                                               0x803C
+#define GL_ALPHA12                                              0x803D
+#define GL_ALPHA16                                              0x803E
+#define GL_LUMINANCE4                                           0x803F
+#define GL_LUMINANCE8                                           0x8040
+#define GL_LUMINANCE12                                          0x8041
+#define GL_LUMINANCE16                                          0x8042
+#define GL_LUMINANCE4_ALPHA4                                    0x8043
+#define GL_LUMINANCE6_ALPHA2                                    0x8044
+#define GL_LUMINANCE8_ALPHA8                                    0x8045
+#define GL_LUMINANCE12_ALPHA4                                   0x8046
+#define GL_LUMINANCE12_ALPHA12                                  0x8047
+#define GL_LUMINANCE16_ALPHA16                                  0x8048
+#define GL_INTENSITY                                            0x8049
+#define GL_INTENSITY4                                           0x804A
+#define GL_INTENSITY8                                           0x804B
+#define GL_INTENSITY12                                          0x804C
+#define GL_INTENSITY16                                          0x804D
+#define GL_R3_G3_B2                                             0x2A10
+#define GL_RGB4                                                 0x804F
+#define GL_RGB5                                                 0x8050
+#define GL_RGB8                                                 0x8051
+#define GL_RGB10                                                0x8052
+#define GL_RGB12                                                0x8053
+#define GL_RGB16                                                0x8054
+#define GL_RGBA2                                                0x8055
+#define GL_RGBA4                                                0x8056
+#define GL_RGB5_A1                                              0x8057
+#define GL_RGBA8                                                0x8058
+#define GL_RGB10_A2                                             0x8059
+#define GL_RGBA12                                               0x805A
+#define GL_RGBA16                                               0x805B
+#define GL_TEXTURE_RED_SIZE                                     0x805C
+#define GL_TEXTURE_GREEN_SIZE                                   0x805D
+#define GL_TEXTURE_BLUE_SIZE                                    0x805E
+#define GL_TEXTURE_ALPHA_SIZE                                   0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE                               0x8060
+#define GL_TEXTURE_INTENSITY_SIZE                               0x8061
+#define GL_PROXY_TEXTURE_1D                                     0x8063
+#define GL_PROXY_TEXTURE_2D                                     0x8064
+#define GL_TEXTURE_PRIORITY                                     0x8066
+#define GL_TEXTURE_RESIDENT                                     0x8067
+#define GL_TEXTURE_BINDING_1D                                   0x8068
+#define GL_TEXTURE_BINDING_2D                                   0x8069
+#define GL_VERTEX_ARRAY                                         0x8074
+#define GL_NORMAL_ARRAY                                         0x8075
+#define GL_COLOR_ARRAY                                          0x8076
+#define GL_INDEX_ARRAY                                          0x8077
+#define GL_TEXTURE_COORD_ARRAY                                  0x8078
+#define GL_EDGE_FLAG_ARRAY                                      0x8079
+#define GL_VERTEX_ARRAY_SIZE                                    0x807A
+#define GL_VERTEX_ARRAY_TYPE                                    0x807B
+#define GL_VERTEX_ARRAY_STRIDE                                  0x807C
+#define GL_NORMAL_ARRAY_TYPE                                    0x807E
+#define GL_NORMAL_ARRAY_STRIDE                                  0x807F
+#define GL_COLOR_ARRAY_SIZE                                     0x8081
+#define GL_COLOR_ARRAY_TYPE                                     0x8082
+#define GL_COLOR_ARRAY_STRIDE                                   0x8083
+#define GL_INDEX_ARRAY_TYPE                                     0x8085
+#define GL_INDEX_ARRAY_STRIDE                                   0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE                             0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE                             0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE                           0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE                               0x808C
+#define GL_VERTEX_ARRAY_POINTER                                 0x808E
+#define GL_NORMAL_ARRAY_POINTER                                 0x808F
+#define GL_COLOR_ARRAY_POINTER                                  0x8090
+#define GL_INDEX_ARRAY_POINTER                                  0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER                          0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER                              0x8093
+#define GL_V2F                                                  0x2A20
+#define GL_V3F                                                  0x2A21
+#define GL_C4UB_V2F                                             0x2A22
+#define GL_C4UB_V3F                                             0x2A23
+#define GL_C3F_V3F                                              0x2A24
+#define GL_N3F_V3F                                              0x2A25
+#define GL_C4F_N3F_V3F                                          0x2A26
+#define GL_T2F_V3F                                              0x2A27
+#define GL_T4F_V4F                                              0x2A28
+#define GL_T2F_C4UB_V3F                                         0x2A29
+#define GL_T2F_C3F_V3F                                          0x2A2A
+#define GL_T2F_N3F_V3F                                          0x2A2B
+#define GL_T2F_C4F_N3F_V3F                                      0x2A2C
+#define GL_T4F_C4F_N3F_V4F                                      0x2A2D
+#define GL_LOGIC_OP GL_INDEX_LOGIC_OP
+#define GL_TEXTURE_COMPONENTS GL_TEXTURE_INTERNAL_FORMAT
+
+/* functions */
+
+extern void APIENTRY glAccum (GLenum op, GLfloat value);
+extern void APIENTRY glAlphaFunc (GLenum func, GLclampf ref);
+extern GLboolean APIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences);
+extern void APIENTRY glArrayElement (GLint i);
+extern void APIENTRY glBegin (GLenum mode);
+extern void APIENTRY glBindTexture (GLenum target, GLuint texture);
+extern void APIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern void APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+extern void APIENTRY glCallList (GLuint list);
+extern void APIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists);
+extern void APIENTRY glClear (GLbitfield mask);
+extern void APIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern void APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern void APIENTRY glClearDepth (GLclampd depth);
+extern void APIENTRY glClearIndex (GLfloat c);
+extern void APIENTRY glClearStencil (GLint s);
+extern void APIENTRY glClipPlane (GLenum plane, const GLdouble *equation);
+extern void APIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue);
+extern void APIENTRY glColor3bv (const GLbyte *v);
+extern void APIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue);
+extern void APIENTRY glColor3dv (const GLdouble *v);
+extern void APIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue);
+extern void APIENTRY glColor3fv (const GLfloat *v);
+extern void APIENTRY glColor3i (GLint red, GLint green, GLint blue);
+extern void APIENTRY glColor3iv (const GLint *v);
+extern void APIENTRY glColor3s (GLshort red, GLshort green, GLshort blue);
+extern void APIENTRY glColor3sv (const GLshort *v);
+extern void APIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+extern void APIENTRY glColor3ubv (const GLubyte *v);
+extern void APIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue);
+extern void APIENTRY glColor3uiv (const GLuint *v);
+extern void APIENTRY glColor3us (GLushort red, GLushort green, GLushort blue);
+extern void APIENTRY glColor3usv (const GLushort *v);
+extern void APIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern void APIENTRY glColor4bv (const GLbyte *v);
+extern void APIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern void APIENTRY glColor4dv (const GLdouble *v);
+extern void APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern void APIENTRY glColor4fv (const GLfloat *v);
+extern void APIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha);
+extern void APIENTRY glColor4iv (const GLint *v);
+extern void APIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern void APIENTRY glColor4sv (const GLshort *v);
+extern void APIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern void APIENTRY glColor4ubv (const GLubyte *v);
+extern void APIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern void APIENTRY glColor4uiv (const GLuint *v);
+extern void APIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern void APIENTRY glColor4usv (const GLushort *v);
+extern void APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern void APIENTRY glColorMaterial (GLenum face, GLenum mode);
+extern void APIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern void APIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern void APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern void APIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern void APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern void APIENTRY glCullFace (GLenum mode);
+extern void APIENTRY glDeleteLists (GLuint list, GLsizei range);
+extern void APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
+extern void APIENTRY glDepthFunc (GLenum func);
+extern void APIENTRY glDepthMask (GLboolean flag);
+extern void APIENTRY glDepthRange (GLclampd zNear, GLclampd zFar);
+extern void APIENTRY glDisable (GLenum cap);
+extern void APIENTRY glDisableClientState (GLenum array);
+extern void APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+extern void APIENTRY glDrawBuffer (GLenum mode);
+extern void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern void APIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glEdgeFlag (GLboolean flag);
+#ifndef __MACH__
+extern void APIENTRY glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer);
+#endif
+extern void APIENTRY glEdgeFlagv (const GLboolean *flag);
+extern void APIENTRY glEnable (GLenum cap);
+extern void APIENTRY glEnableClientState (GLenum array);
+extern void APIENTRY glEnd (void);
+extern void APIENTRY glEndList (void);
+extern void APIENTRY glEvalCoord1d (GLdouble u);
+extern void APIENTRY glEvalCoord1dv (const GLdouble *u);
+extern void APIENTRY glEvalCoord1f (GLfloat u);
+extern void APIENTRY glEvalCoord1fv (const GLfloat *u);
+extern void APIENTRY glEvalCoord2d (GLdouble u, GLdouble v);
+extern void APIENTRY glEvalCoord2dv (const GLdouble *u);
+extern void APIENTRY glEvalCoord2f (GLfloat u, GLfloat v);
+extern void APIENTRY glEvalCoord2fv (const GLfloat *u);
+extern void APIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2);
+extern void APIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern void APIENTRY glEvalPoint1 (GLint i);
+extern void APIENTRY glEvalPoint2 (GLint i, GLint j);
+extern void APIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer);
+extern void APIENTRY glFinish (void);
+extern void APIENTRY glFlush (void);
+extern void APIENTRY glFogf (GLenum pname, GLfloat param);
+extern void APIENTRY glFogfv (GLenum pname, const GLfloat *params);
+extern void APIENTRY glFogi (GLenum pname, GLint param);
+extern void APIENTRY glFogiv (GLenum pname, const GLint *params);
+extern void APIENTRY glFrontFace (GLenum mode);
+extern void APIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern GLuint APIENTRY glGenLists (GLsizei range);
+extern void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
+extern void APIENTRY glGetBooleanv (GLenum pname, GLboolean *params);
+extern void APIENTRY glGetClipPlane (GLenum plane, GLdouble *equation);
+extern void APIENTRY glGetDoublev (GLenum pname, GLdouble *params);
+extern GLenum APIENTRY glGetError (void);
+extern void APIENTRY glGetFloatv (GLenum pname, GLfloat *params);
+extern void APIENTRY glGetIntegerv (GLenum pname, GLint *params);
+extern void APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params);
+extern void APIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v);
+extern void APIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v);
+extern void APIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v);
+extern void APIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params);
+extern void APIENTRY glGetPixelMapfv (GLenum map, GLfloat *values);
+extern void APIENTRY glGetPixelMapuiv (GLenum map, GLuint *values);
+extern void APIENTRY glGetPixelMapusv (GLenum map, GLushort *values);
+extern void APIENTRY glGetPointerv (GLenum pname, GLvoid* *params);
+extern void APIENTRY glGetPolygonStipple (GLubyte *mask);
+extern const GLubyte * APIENTRY glGetString (GLenum name);
+extern void APIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);
+extern void APIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern void APIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params);
+extern void APIENTRY glHint (GLenum target, GLenum mode);
+extern void APIENTRY glIndexMask (GLuint mask);
+extern void APIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glIndexd (GLdouble c);
+extern void APIENTRY glIndexdv (const GLdouble *c);
+extern void APIENTRY glIndexf (GLfloat c);
+extern void APIENTRY glIndexfv (const GLfloat *c);
+extern void APIENTRY glIndexi (GLint c);
+extern void APIENTRY glIndexiv (const GLint *c);
+extern void APIENTRY glIndexs (GLshort c);
+extern void APIENTRY glIndexsv (const GLshort *c);
+extern void APIENTRY glIndexub (GLubyte c);
+extern void APIENTRY glIndexubv (const GLubyte *c);
+extern void APIENTRY glInitNames (void);
+extern void APIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer);
+extern GLboolean APIENTRY glIsEnabled (GLenum cap);
+extern GLboolean APIENTRY glIsList (GLuint list);
+extern GLboolean APIENTRY glIsTexture (GLuint texture);
+extern void APIENTRY glLightModelf (GLenum pname, GLfloat param);
+extern void APIENTRY glLightModelfv (GLenum pname, const GLfloat *params);
+extern void APIENTRY glLightModeli (GLenum pname, GLint param);
+extern void APIENTRY glLightModeliv (GLenum pname, const GLint *params);
+extern void APIENTRY glLightf (GLenum light, GLenum pname, GLfloat param);
+extern void APIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params);
+extern void APIENTRY glLighti (GLenum light, GLenum pname, GLint param);
+extern void APIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params);
+extern void APIENTRY glLineStipple (GLint factor, GLushort pattern);
+extern void APIENTRY glLineWidth (GLfloat width);
+extern void APIENTRY glListBase (GLuint base);
+extern void APIENTRY glLoadIdentity (void);
+extern void APIENTRY glLoadMatrixd (const GLdouble *m);
+extern void APIENTRY glLoadMatrixf (const GLfloat *m);
+extern void APIENTRY glLoadName (GLuint name);
+extern void APIENTRY glLogicOp (GLenum opcode);
+extern void APIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern void APIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern void APIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern void APIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern void APIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2);
+extern void APIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2);
+extern void APIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern void APIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern void APIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param);
+extern void APIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
+extern void APIENTRY glMateriali (GLenum face, GLenum pname, GLint param);
+extern void APIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params);
+extern void APIENTRY glMatrixMode (GLenum mode);
+extern void APIENTRY glMultMatrixd (const GLdouble *m);
+extern void APIENTRY glMultMatrixf (const GLfloat *m);
+extern void APIENTRY glNewList (GLuint list, GLenum mode);
+extern void APIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz);
+extern void APIENTRY glNormal3bv (const GLbyte *v);
+extern void APIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz);
+extern void APIENTRY glNormal3dv (const GLdouble *v);
+extern void APIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz);
+extern void APIENTRY glNormal3fv (const GLfloat *v);
+extern void APIENTRY glNormal3i (GLint nx, GLint ny, GLint nz);
+extern void APIENTRY glNormal3iv (const GLint *v);
+extern void APIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz);
+extern void APIENTRY glNormal3sv (const GLshort *v);
+extern void APIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern void APIENTRY glPassThrough (GLfloat token);
+extern void APIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values);
+extern void APIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values);
+extern void APIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values);
+extern void APIENTRY glPixelStoref (GLenum pname, GLfloat param);
+extern void APIENTRY glPixelStorei (GLenum pname, GLint param);
+extern void APIENTRY glPixelTransferf (GLenum pname, GLfloat param);
+extern void APIENTRY glPixelTransferi (GLenum pname, GLint param);
+extern void APIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor);
+extern void APIENTRY glPointSize (GLfloat size);
+extern void APIENTRY glPolygonMode (GLenum face, GLenum mode);
+extern void APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+extern void APIENTRY glPolygonStipple (const GLubyte *mask);
+extern void APIENTRY glPopAttrib (void);
+extern void APIENTRY glPopClientAttrib (void);
+extern void APIENTRY glPopMatrix (void);
+extern void APIENTRY glPopName (void);
+extern void APIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern void APIENTRY glPushAttrib (GLbitfield mask);
+extern void APIENTRY glPushClientAttrib (GLbitfield mask);
+extern void APIENTRY glPushMatrix (void);
+extern void APIENTRY glPushName (GLuint name);
+extern void APIENTRY glRasterPos2d (GLdouble x, GLdouble y);
+extern void APIENTRY glRasterPos2dv (const GLdouble *v);
+extern void APIENTRY glRasterPos2f (GLfloat x, GLfloat y);
+extern void APIENTRY glRasterPos2fv (const GLfloat *v);
+extern void APIENTRY glRasterPos2i (GLint x, GLint y);
+extern void APIENTRY glRasterPos2iv (const GLint *v);
+extern void APIENTRY glRasterPos2s (GLshort x, GLshort y);
+extern void APIENTRY glRasterPos2sv (const GLshort *v);
+extern void APIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glRasterPos3dv (const GLdouble *v);
+extern void APIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glRasterPos3fv (const GLfloat *v);
+extern void APIENTRY glRasterPos3i (GLint x, GLint y, GLint z);
+
+extern void APIENTRY glRasterPos3iv (const GLint *v);
+extern void APIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z);
+extern void APIENTRY glRasterPos3sv (const GLshort *v);
+extern void APIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern void APIENTRY glRasterPos4dv (const GLdouble *v);
+extern void APIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern void APIENTRY glRasterPos4fv (const GLfloat *v);
+extern void APIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w);
+extern void APIENTRY glRasterPos4iv (const GLint *v);
+extern void APIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w);
+extern void APIENTRY glRasterPos4sv (const GLshort *v);
+extern void APIENTRY glReadBuffer (GLenum mode);
+extern void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+extern void APIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern void APIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2);
+extern void APIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern void APIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2);
+extern void APIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2);
+extern void APIENTRY glRectiv (const GLint *v1, const GLint *v2);
+extern void APIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern void APIENTRY glRectsv (const GLshort *v1, const GLshort *v2);
+extern GLint APIENTRY glRenderMode (GLenum mode);
+extern void APIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+extern void APIENTRY glSelectBuffer (GLsizei size, GLuint *buffer);
+extern void APIENTRY glShadeModel (GLenum mode);
+extern void APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+extern void APIENTRY glStencilMask (GLuint mask);
+extern void APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+extern void APIENTRY glTexCoord1d (GLdouble s);
+extern void APIENTRY glTexCoord1dv (const GLdouble *v);
+extern void APIENTRY glTexCoord1f (GLfloat s);
+extern void APIENTRY glTexCoord1fv (const GLfloat *v);
+extern void APIENTRY glTexCoord1i (GLint s);
+extern void APIENTRY glTexCoord1iv (const GLint *v);
+extern void APIENTRY glTexCoord1s (GLshort s);
+extern void APIENTRY glTexCoord1sv (const GLshort *v);
+extern void APIENTRY glTexCoord2d (GLdouble s, GLdouble t);
+extern void APIENTRY glTexCoord2dv (const GLdouble *v);
+extern void APIENTRY glTexCoord2f (GLfloat s, GLfloat t);
+extern void APIENTRY glTexCoord2fv (const GLfloat *v);
+extern void APIENTRY glTexCoord2i (GLint s, GLint t);
+extern void APIENTRY glTexCoord2iv (const GLint *v);
+extern void APIENTRY glTexCoord2s (GLshort s, GLshort t);
+extern void APIENTRY glTexCoord2sv (const GLshort *v);
+extern void APIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r);
+extern void APIENTRY glTexCoord3dv (const GLdouble *v);
+extern void APIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r);
+extern void APIENTRY glTexCoord3fv (const GLfloat *v);
+extern void APIENTRY glTexCoord3i (GLint s, GLint t, GLint r);
+extern void APIENTRY glTexCoord3iv (const GLint *v);
+extern void APIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r);
+extern void APIENTRY glTexCoord3sv (const GLshort *v);
+extern void APIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern void APIENTRY glTexCoord4dv (const GLdouble *v);
+extern void APIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern void APIENTRY glTexCoord4fv (const GLfloat *v);
+extern void APIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q);
+extern void APIENTRY glTexCoord4iv (const GLint *v);
+extern void APIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q);
+extern void APIENTRY glTexCoord4sv (const GLshort *v);
+extern void APIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param);
+extern void APIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param);
+extern void APIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params);
+extern void APIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param);
+extern void APIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);
+extern void APIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param);
+extern void APIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param);
+extern void APIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params);
+#ifndef __MACH__
+extern void APIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+extern void APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+extern void APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+extern void APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params);
+extern void APIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glVertex2d (GLdouble x, GLdouble y);
+extern void APIENTRY glVertex2dv (const GLdouble *v);
+extern void APIENTRY glVertex2f (GLfloat x, GLfloat y);
+extern void APIENTRY glVertex2fv (const GLfloat *v);
+extern void APIENTRY glVertex2i (GLint x, GLint y);
+extern void APIENTRY glVertex2iv (const GLint *v);
+extern void APIENTRY glVertex2s (GLshort x, GLshort y);
+extern void APIENTRY glVertex2sv (const GLshort *v);
+extern void APIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glVertex3dv (const GLdouble *v);
+extern void APIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glVertex3fv (const GLfloat *v);
+extern void APIENTRY glVertex3i (GLint x, GLint y, GLint z);
+extern void APIENTRY glVertex3iv (const GLint *v);
+extern void APIENTRY glVertex3s (GLshort x, GLshort y, GLshort z);
+extern void APIENTRY glVertex3sv (const GLshort *v);
+extern void APIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern void APIENTRY glVertex4dv (const GLdouble *v);
+extern void APIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern void APIENTRY glVertex4fv (const GLfloat *v);
+extern void APIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w);
+extern void APIENTRY glVertex4iv (const GLint *v);
+extern void APIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
+extern void APIENTRY glVertex4sv (const GLshort *v);
+extern void APIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+
+/* OpenGL 1.2 */
+
+#ifndef GL_VERSION_1_2
+#define GL_ARB_imaging 1
+#define GL_VERSION_1_2 1
+#define GL_RESCALE_NORMAL                                       0x803A
+#define GL_CLAMP_TO_EDGE                                        0x812F
+#define GL_MAX_ELEMENTS_VERTICES                                0x80E8
+#define GL_MAX_ELEMENTS_INDICES                                 0x80E9
+#define GL_BGR                                                  0x80E0
+#define GL_BGRA                                                 0x80E1
+#define GL_UNSIGNED_BYTE_3_3_2                                  0x8032
+#define GL_UNSIGNED_BYTE_2_3_3_REV                              0x8362
+#define GL_UNSIGNED_SHORT_5_6_5                                 0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV                             0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4                               0x8033
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV                           0x8365
+#define GL_UNSIGNED_SHORT_5_5_5_1                               0x8034
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV                           0x8366
+#define GL_UNSIGNED_INT_8_8_8_8                                 0x8035
+#define GL_UNSIGNED_INT_8_8_8_8_REV                             0x8367
+#define GL_UNSIGNED_INT_10_10_10_2                              0x8036
+#define GL_UNSIGNED_INT_2_10_10_10_REV                          0x8368
+#define GL_LIGHT_MODEL_COLOR_CONTROL                            0x81F8
+#define GL_SINGLE_COLOR                                         0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR                              0x81FA
+#define GL_TEXTURE_MIN_LOD                                      0x813A
+#define GL_TEXTURE_MAX_LOD                                      0x813B
+#define GL_TEXTURE_BASE_LEVEL                                   0x813C
+#define GL_TEXTURE_MAX_LEVEL                                    0x813D
+#define GL_SMOOTH_POINT_SIZE_RANGE                              0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY                        0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE                              0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY                        0x0B23
+#define GL_ALIASED_POINT_SIZE_RANGE                             0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE                             0x846E
+#define GL_PACK_SKIP_IMAGES                                     0x806B
+#define GL_PACK_IMAGE_HEIGHT                                    0x806C
+#define GL_UNPACK_SKIP_IMAGES                                   0x806D
+#define GL_UNPACK_IMAGE_HEIGHT                                  0x806E
+#define GL_TEXTURE_3D                                           0x806F
+#define GL_PROXY_TEXTURE_3D                                     0x8070
+#define GL_TEXTURE_DEPTH                                        0x8071
+#define GL_TEXTURE_WRAP_R                                       0x8072
+#define GL_MAX_3D_TEXTURE_SIZE                                  0x8073
+#define GL_TEXTURE_BINDING_3D                                   0x806A
+#define GL_COLOR_TABLE                                          0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE                         0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE                        0x80D2
+#define GL_PROXY_COLOR_TABLE                                    0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE                   0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE                  0x80D5
+#define GL_COLOR_TABLE_SCALE                                    0x80D6
+#define GL_COLOR_TABLE_BIAS                                     0x80D7
+#define GL_COLOR_TABLE_FORMAT                                   0x80D8
+#define GL_COLOR_TABLE_WIDTH                                    0x80D9
+#define GL_COLOR_TABLE_RED_SIZE                                 0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE                               0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE                                0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE                               0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE                           0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE                           0x80DF
+#define GL_CONVOLUTION_1D                                       0x8010
+#define GL_CONVOLUTION_2D                                       0x8011
+#define GL_SEPARABLE_2D                                         0x8012
+#define GL_CONVOLUTION_BORDER_MODE                              0x8013
+#define GL_CONVOLUTION_FILTER_SCALE                             0x8014
+#define GL_CONVOLUTION_FILTER_BIAS                              0x8015
+#define GL_REDUCE                                               0x8016
+#define GL_CONVOLUTION_FORMAT                                   0x8017
+#define GL_CONVOLUTION_WIDTH                                    0x8018
+#define GL_CONVOLUTION_HEIGHT                                   0x8019
+#define GL_MAX_CONVOLUTION_WIDTH                                0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT                               0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE                           0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE                         0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE                          0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE                         0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS                            0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS                          0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS                           0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS                          0x8023
+#define GL_CONSTANT_BORDER                                      0x8151
+#define GL_REPLICATE_BORDER                                     0x8153
+#define GL_CONVOLUTION_BORDER_COLOR                             0x8154
+#define GL_COLOR_MATRIX                                         0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH                             0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH                         0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE                          0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE                        0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE                         0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE                        0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS                           0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS                         0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS                          0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS                         0x80BB
+#define GL_HISTOGRAM                                            0x8024
+#define GL_PROXY_HISTOGRAM                                      0x8025
+#define GL_HISTOGRAM_WIDTH                                      0x8026
+#define GL_HISTOGRAM_FORMAT                                     0x8027
+#define GL_HISTOGRAM_RED_SIZE                                   0x8028
+#define GL_HISTOGRAM_GREEN_SIZE                                 0x8029
+#define GL_HISTOGRAM_BLUE_SIZE                                  0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE                                 0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE                             0x802C
+#define GL_HISTOGRAM_SINK                                       0x802D
+#define GL_MINMAX                                               0x802E
+#define GL_MINMAX_FORMAT                                        0x802F
+#define GL_MINMAX_SINK                                          0x8030
+#define GL_TABLE_TOO_LARGE                                      0x8031
+#define GL_BLEND_EQUATION                                       0x8009
+#define GL_MIN                                                  0x8007
+#define GL_MAX                                                  0x8008
+#define GL_FUNC_ADD                                             0x8006
+#define GL_FUNC_SUBTRACT                                        0x800A
+#define GL_FUNC_REVERSE_SUBTRACT                                0x800B
+#define GL_BLEND_COLOR                                          0x8005
+#define GL_CONSTANT_COLOR                                       0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR                             0x8002
+#define GL_CONSTANT_ALPHA                                       0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA                             0x8004
+
+typedef void (APIENTRY * glColorTablePROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table );
+typedef void (APIENTRY * glColorSubTablePROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data );
+typedef void (APIENTRY * glColorTableParameterivPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * glColorTableParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glCopyColorSubTablePROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
+typedef void (APIENTRY * glCopyColorTablePROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+typedef void (APIENTRY * glGetColorTablePROC) (GLenum target, GLenum format, GLenum type, GLvoid *table );
+typedef void (APIENTRY * glGetColorTableParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
+typedef void (APIENTRY * glGetColorTableParameterivPROC) (GLenum target, GLenum pname, GLint *params );
+typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode );
+typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
+typedef void (APIENTRY * glHistogramPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
+typedef void (APIENTRY * glResetHistogramPROC) (GLenum target );
+typedef void (APIENTRY * glGetHistogramPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values );
+typedef void (APIENTRY * glGetHistogramParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
+typedef void (APIENTRY * glGetHistogramParameterivPROC) (GLenum target, GLenum pname, GLint *params );
+typedef void (APIENTRY * glMinmaxPROC) (GLenum target, GLenum internalformat, GLboolean sink );
+typedef void (APIENTRY * glResetMinmaxPROC) (GLenum target );
+typedef void (APIENTRY * glGetMinmaxPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values );
+typedef void (APIENTRY * glGetMinmaxParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
+typedef void (APIENTRY * glGetMinmaxParameterivPROC) (GLenum target, GLenum pname, GLint *params );
+typedef void (APIENTRY * glConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image );
+typedef void (APIENTRY * glConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image );
+typedef void (APIENTRY * glConvolutionParameterfPROC) (GLenum target, GLenum pname, GLfloat params );
+typedef void (APIENTRY * glConvolutionParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params );
+typedef void (APIENTRY * glConvolutionParameteriPROC) (GLenum target, GLenum pname, GLint params );
+typedef void (APIENTRY * glConvolutionParameterivPROC) (GLenum target, GLenum pname, const GLint *params );
+typedef void (APIENTRY * glCopyConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+typedef void (APIENTRY * glCopyConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * glGetConvolutionFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image );
+typedef void (APIENTRY * glGetConvolutionParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params );
+typedef void (APIENTRY * glGetConvolutionParameterivPROC) (GLenum target, GLenum pname, GLint *params );
+typedef void (APIENTRY * glSeparableFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column );
+typedef void (APIENTRY * glGetSeparableFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
+typedef void (APIENTRY * glDrawRangeElementsPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
+typedef void (APIENTRY * glTexImage3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
+typedef void (APIENTRY * glTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * glCopyTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+
+#ifdef _WIN32
+
+extern glBlendColorPROC glBlendColor;
+LIB_RENDERING_EXPORT
+extern glBlendEquationPROC glBlendEquation;
+extern glColorTablePROC glColorTable;
+extern glColorTableParameterfvPROC glColorTableParameterfv;
+extern glColorTableParameterivPROC glColorTableParameteriv;
+extern glCopyColorTablePROC glCopyColorTable;
+extern glGetColorTablePROC glGetColorTable;
+extern glGetColorTableParameterfvPROC glGetColorTableParameterfv;
+extern glGetColorTableParameterivPROC glGetColorTableParameteriv;
+extern glColorSubTablePROC glColorSubTable;
+extern glCopyColorSubTablePROC glCopyColorSubTable;
+extern glConvolutionFilter1DPROC glConvolutionFilter1D;
+extern glConvolutionFilter2DPROC glConvolutionFilter2D;
+extern glConvolutionParameterfPROC glConvolutionParameterf;
+extern glConvolutionParameterfvPROC glConvolutionParameterfv;
+extern glConvolutionParameteriPROC glConvolutionParameteri;
+extern glConvolutionParameterivPROC glConvolutionParameteriv;
+extern glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D;
+extern glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D;
+extern glGetConvolutionFilterPROC glGetConvolutionFilter;
+extern glGetConvolutionParameterfvPROC glGetConvolutionParameterfv;
+extern glGetConvolutionParameterivPROC glGetConvolutionParameteriv;
+extern glGetSeparableFilterPROC glGetSeparableFilter;
+extern glSeparableFilter2DPROC glSeparableFilter2D;
+extern glGetHistogramPROC glGetHistogram;
+extern glGetHistogramParameterfvPROC glGetHistogramParameterfv;
+extern glGetHistogramParameterivPROC glGetHistogramParameteriv;
+extern glGetMinmaxPROC glGetMinmax;
+extern glGetMinmaxParameterfvPROC glGetMinmaxParameterfv;
+extern glGetMinmaxParameterivPROC glGetMinmaxParameteriv;
+extern glHistogramPROC glHistogram;
+extern glMinmaxPROC glMinmax;
+extern glResetHistogramPROC glResetHistogram;
+extern glResetMinmaxPROC glResetMinmax;
+extern glDrawRangeElementsPROC glDrawRangeElements;
+extern glTexImage3DPROC glTexImage3D;
+extern glTexSubImage3DPROC glTexSubImage3D;
+extern glCopyTexSubImage3DPROC glCopyTexSubImage3D;
+
+#else
+
+extern void APIENTRY glColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table );
+extern void APIENTRY glColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data );
+extern void APIENTRY glColorTableParameteriv (GLenum target, GLenum pname, const GLint *params);
+extern void APIENTRY glColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+extern void APIENTRY glCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
+extern void APIENTRY glCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+extern void APIENTRY glGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table );
+extern void APIENTRY glGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params );
+extern void APIENTRY glGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params );
+extern void APIENTRY glBlendEquation (GLenum mode );
+extern void APIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
+extern void APIENTRY glHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
+extern void APIENTRY glResetHistogram (GLenum target );
+extern void APIENTRY glGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values );
+extern void APIENTRY glGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params );
+extern void APIENTRY glGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params );
+extern void APIENTRY glMinmax (GLenum target, GLenum internalformat, GLboolean sink );
+extern void APIENTRY glResetMinmax (GLenum target );
+extern void APIENTRY glGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values );
+extern void APIENTRY glGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params );
+extern void APIENTRY glGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params );
+extern void APIENTRY glConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image );
+extern void APIENTRY glConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image );
+extern void APIENTRY glConvolutionParameterf (GLenum target, GLenum pname, GLfloat params );
+extern void APIENTRY glConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params );
+extern void APIENTRY glConvolutionParameteri (GLenum target, GLenum pname, GLint params );
+extern void APIENTRY glConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params );
+extern void APIENTRY glCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+extern void APIENTRY glCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+extern void APIENTRY glGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image );
+extern void APIENTRY glGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params );
+extern void APIENTRY glGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params );
+extern void APIENTRY glSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column );
+extern void APIENTRY glGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
+extern void APIENTRY glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
+extern void APIENTRY glTexImage3D (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels );
+extern void APIENTRY glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+
+#endif /* WIN32 */
+
+#endif /* GL_VERSION_1_2 */
+
+/* OpenGL 1.3 */
+
+#ifndef GL_VERSION_1_3
+#define GL_VERSION_1_3 1
+#define GL_TEXTURE0                                             0x84C0
+#define GL_TEXTURE1                                             0x84C1
+#define GL_TEXTURE2                                             0x84C2
+#define GL_TEXTURE3                                             0x84C3
+#define GL_TEXTURE4                                             0x84C4
+#define GL_TEXTURE5                                             0x84C5
+#define GL_TEXTURE6                                             0x84C6
+#define GL_TEXTURE7                                             0x84C7
+#define GL_TEXTURE8                                             0x84C8
+#define GL_TEXTURE9                                             0x84C9
+#define GL_TEXTURE10                                            0x84CA
+#define GL_TEXTURE11                                            0x84CB
+#define GL_TEXTURE12                                            0x84CC
+#define GL_TEXTURE13                                            0x84CD
+#define GL_TEXTURE14                                            0x84CE
+#define GL_TEXTURE15                                            0x84CF
+#define GL_TEXTURE16                                            0x84D0
+#define GL_TEXTURE17                                            0x84D1
+#define GL_TEXTURE18                                            0x84D2
+#define GL_TEXTURE19                                            0x84D3
+#define GL_TEXTURE20                                            0x84D4
+#define GL_TEXTURE21                                            0x84D5
+#define GL_TEXTURE22                                            0x84D6
+#define GL_TEXTURE23                                            0x84D7
+#define GL_TEXTURE24                                            0x84D8
+#define GL_TEXTURE25                                            0x84D9
+#define GL_TEXTURE26                                            0x84DA
+#define GL_TEXTURE27                                            0x84DB
+#define GL_TEXTURE28                                            0x84DC
+#define GL_TEXTURE29                                            0x84DD
+#define GL_TEXTURE30                                            0x84DE
+#define GL_TEXTURE31                                            0x84DF
+#define GL_ACTIVE_TEXTURE                                       0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE                                0x84E1
+#define GL_MAX_TEXTURE_UNITS                                    0x84E2
+
+#define GL_NORMAL_MAP                                           0x8511
+#define GL_REFLECTION_MAP                                       0x8512
+#define GL_TEXTURE_CUBE_MAP                                     0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP                             0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X                          0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X                          0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y                          0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y                          0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z                          0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z                          0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP                               0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE                            0x851C
+
+#define GL_COMPRESSED_ALPHA                                     0x84E9
+#define GL_COMPRESSED_LUMINANCE                                 0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA                           0x84EB
+#define GL_COMPRESSED_INTENSITY                                 0x84EC
+#define GL_COMPRESSED_RGB                                       0x84ED
+#define GL_COMPRESSED_RGBA                                      0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT                             0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE                        0x86A0
+#define GL_TEXTURE_COMPRESSED                                   0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS                       0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS                           0x86A3
+
+#define GL_MULTISAMPLE                                          0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE                             0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE                                  0x809F
+#define GL_SAMPLE_COVERAGE                                      0x80A0
+#define GL_SAMPLE_BUFFERS                                       0x80A8
+#define GL_SAMPLES                                              0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE                                0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT                               0x80AB
+#define GL_MULTISAMPLE_BIT                                      0x20000000
+
+#define GL_TRANSPOSE_MODELVIEW_MATRIX                           0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX                          0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX                             0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX                               0x84E6
+
+#define GL_COMBINE                                              0x8570
+#define GL_COMBINE_RGB                                          0x8571
+#define GL_COMBINE_ALPHA                                        0x8572
+#define GL_SOURCE0_RGB                                          0x8580
+#define GL_SOURCE1_RGB                                          0x8581
+#define GL_SOURCE2_RGB                                          0x8582
+#define GL_SOURCE0_ALPHA                                        0x8588
+#define GL_SOURCE1_ALPHA                                        0x8589
+#define GL_SOURCE2_ALPHA                                        0x858A
+#define GL_OPERAND0_RGB                                         0x8590
+#define GL_OPERAND1_RGB                                         0x8591
+#define GL_OPERAND2_RGB                                         0x8592
+#define GL_OPERAND0_ALPHA                                       0x8598
+#define GL_OPERAND1_ALPHA                                       0x8599
+#define GL_OPERAND2_ALPHA                                       0x859A
+#define GL_RGB_SCALE                                            0x8573
+#define GL_ADD_SIGNED                                           0x8574
+#define GL_INTERPOLATE                                          0x8575
+#define GL_SUBTRACT                                             0x84E7
+#define GL_CONSTANT                                             0x8576
+#define GL_PRIMARY_COLOR                                        0x8577
+#define GL_PREVIOUS                                             0x8578
+#define GL_DOT3_RGB                                             0x86AE
+#define GL_DOT3_RGBA                                            0x86AF
+#define GL_CLAMP_TO_BORDER                                      0x812D
+
+typedef void (APIENTRY * glActiveTexturePROC) (GLenum texture );
+typedef void (APIENTRY * glClientActiveTexturePROC) (GLenum texture );
+typedef void (APIENTRY * glCompressedTexImage1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexImage2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexImage3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glGetCompressedTexImagePROC) (GLenum target, GLint lod, GLvoid *img );
+typedef void (APIENTRY * glMultiTexCoord1dPROC) (GLenum target, GLdouble s );
+typedef void (APIENTRY * glMultiTexCoord1dvPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord1fPROC) (GLenum target, GLfloat s );
+typedef void (APIENTRY * glMultiTexCoord1fvPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord1iPROC) (GLenum target, GLint s );
+typedef void (APIENTRY * glMultiTexCoord1ivPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord1sPROC) (GLenum target, GLshort s );
+typedef void (APIENTRY * glMultiTexCoord1svPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord2dPROC) (GLenum target, GLdouble s, GLdouble t );
+typedef void (APIENTRY * glMultiTexCoord2dvPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t );
+typedef void (APIENTRY * glMultiTexCoord2fvPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord2iPROC) (GLenum target, GLint s, GLint t );
+typedef void (APIENTRY * glMultiTexCoord2ivPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord2sPROC) (GLenum target, GLshort s, GLshort t );
+typedef void (APIENTRY * glMultiTexCoord2svPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord3dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r );
+typedef void (APIENTRY * glMultiTexCoord3dvPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r );
+typedef void (APIENTRY * glMultiTexCoord3fvPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord3iPROC) (GLenum target, GLint s, GLint t, GLint r );
+typedef void (APIENTRY * glMultiTexCoord3ivPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord3sPROC) (GLenum target, GLshort s, GLshort t, GLshort r );
+typedef void (APIENTRY * glMultiTexCoord3svPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord4dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+typedef void (APIENTRY * glMultiTexCoord4dvPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+typedef void (APIENTRY * glMultiTexCoord4fvPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord4iPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q );
+typedef void (APIENTRY * glMultiTexCoord4ivPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord4sPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+typedef void (APIENTRY * glMultiTexCoord4svPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glLoadTransposeMatrixdPROC) (const GLdouble m[16] );
+typedef void (APIENTRY * glLoadTransposeMatrixfPROC) (const GLfloat m[16] );
+typedef void (APIENTRY * glMultTransposeMatrixdPROC) (const GLdouble m[16] );
+typedef void (APIENTRY * glMultTransposeMatrixfPROC) (const GLfloat m[16] );
+typedef void (APIENTRY * glSampleCoveragePROC) (GLclampf value, GLboolean invert );
+
+#ifdef _WIN32
+
+extern glActiveTexturePROC glActiveTexture;
+extern glClientActiveTexturePROC glClientActiveTexture;
+extern glMultiTexCoord1dPROC glMultiTexCoord1d;
+extern glMultiTexCoord1dvPROC glMultiTexCoord1dv;
+extern glMultiTexCoord1fPROC glMultiTexCoord1f;
+extern glMultiTexCoord1fvPROC glMultiTexCoord1fv;
+extern glMultiTexCoord1iPROC glMultiTexCoord1i;
+extern glMultiTexCoord1ivPROC glMultiTexCoord1iv;
+extern glMultiTexCoord1sPROC glMultiTexCoord1s;
+extern glMultiTexCoord1svPROC glMultiTexCoord1sv;
+extern glMultiTexCoord2dPROC glMultiTexCoord2d;
+extern glMultiTexCoord2dvPROC glMultiTexCoord2dv;
+extern glMultiTexCoord2fPROC glMultiTexCoord2f;
+extern glMultiTexCoord2fvPROC glMultiTexCoord2fv;
+extern glMultiTexCoord2iPROC glMultiTexCoord2i;
+extern glMultiTexCoord2ivPROC glMultiTexCoord2iv;
+extern glMultiTexCoord2sPROC glMultiTexCoord2s;
+extern glMultiTexCoord2svPROC glMultiTexCoord2sv;
+extern glMultiTexCoord3dPROC glMultiTexCoord3d;
+extern glMultiTexCoord3dvPROC glMultiTexCoord3dv;
+extern glMultiTexCoord3fPROC glMultiTexCoord3f;
+extern glMultiTexCoord3fvPROC glMultiTexCoord3fv;
+extern glMultiTexCoord3iPROC glMultiTexCoord3i;
+extern glMultiTexCoord3ivPROC glMultiTexCoord3iv;
+extern glMultiTexCoord3sPROC glMultiTexCoord3s;
+extern glMultiTexCoord3svPROC glMultiTexCoord3sv;
+extern glMultiTexCoord4dPROC glMultiTexCoord4d;
+extern glMultiTexCoord4dvPROC glMultiTexCoord4dv;
+extern glMultiTexCoord4fPROC glMultiTexCoord4f;
+extern glMultiTexCoord4fvPROC glMultiTexCoord4fv;
+extern glMultiTexCoord4iPROC glMultiTexCoord4i;
+extern glMultiTexCoord4ivPROC glMultiTexCoord4iv;
+extern glMultiTexCoord4sPROC glMultiTexCoord4s;
+extern glMultiTexCoord4svPROC glMultiTexCoord4sv;
+extern glLoadTransposeMatrixfPROC glLoadTransposeMatrixf;
+extern glLoadTransposeMatrixdPROC glLoadTransposeMatrixd;
+extern glMultTransposeMatrixfPROC glMultTransposeMatrixf;
+extern glMultTransposeMatrixdPROC glMultTransposeMatrixd;
+extern glCompressedTexImage3DPROC glCompressedTexImage3D;
+extern glCompressedTexImage2DPROC glCompressedTexImage2D;
+extern glCompressedTexImage1DPROC glCompressedTexImage1D;
+extern glCompressedTexSubImage3DPROC glCompressedTexSubImage3D;
+extern glCompressedTexSubImage2DPROC glCompressedTexSubImage2D;
+extern glCompressedTexSubImage1DPROC glCompressedTexSubImage1D;
+extern glGetCompressedTexImagePROC glGetCompressedTexImage;
+extern glSampleCoveragePROC glSampleCoverage;
+
+#else
+
+extern void APIENTRY glActiveTexture (GLenum texture );
+extern void APIENTRY glClientActiveTexture (GLenum texture );
+extern void APIENTRY glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
+extern void APIENTRY glGetCompressedTexImage (GLenum target, GLint lod, GLvoid *img );
+extern void APIENTRY glMultiTexCoord1d (GLenum target, GLdouble s );
+extern void APIENTRY glMultiTexCoord1dv (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord1f (GLenum target, GLfloat s );
+extern void APIENTRY glMultiTexCoord1fv (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord1i (GLenum target, GLint s );
+extern void APIENTRY glMultiTexCoord1iv (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord1s (GLenum target, GLshort s );
+extern void APIENTRY glMultiTexCoord1sv (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord2d (GLenum target, GLdouble s, GLdouble t );
+extern void APIENTRY glMultiTexCoord2dv (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord2f (GLenum target, GLfloat s, GLfloat t );
+extern void APIENTRY glMultiTexCoord2fv (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord2i (GLenum target, GLint s, GLint t );
+extern void APIENTRY glMultiTexCoord2iv (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord2s (GLenum target, GLshort s, GLshort t );
+extern void APIENTRY glMultiTexCoord2sv (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord3d (GLenum target, GLdouble s, GLdouble t, GLdouble r );
+extern void APIENTRY glMultiTexCoord3dv (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord3f (GLenum target, GLfloat s, GLfloat t, GLfloat r );
+extern void APIENTRY glMultiTexCoord3fv (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord3i (GLenum target, GLint s, GLint t, GLint r );
+extern void APIENTRY glMultiTexCoord3iv (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord3s (GLenum target, GLshort s, GLshort t, GLshort r );
+extern void APIENTRY glMultiTexCoord3sv (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord4d (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+extern void APIENTRY glMultiTexCoord4dv (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+extern void APIENTRY glMultiTexCoord4fv (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord4i (GLenum target, GLint s, GLint t, GLint r, GLint q );
+extern void APIENTRY glMultiTexCoord4iv (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord4s (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+extern void APIENTRY glMultiTexCoord4sv (GLenum target, const GLshort *v );
+extern void APIENTRY glLoadTransposeMatrixd (const GLdouble m[16] );
+extern void APIENTRY glLoadTransposeMatrixf (const GLfloat m[16] );
+extern void APIENTRY glMultTransposeMatrixd (const GLdouble m[16] );
+extern void APIENTRY glMultTransposeMatrixf (const GLfloat m[16] );
+extern void APIENTRY glSampleCoverage (GLclampf value, GLboolean invert );
+
+#endif /* WIN32 */
+
+#endif /* GL_VERSION_1_3 */
+
+/* OpenGL 1.4 */
+
+#ifndef GL_VERSION_1_4
+#define GL_VERSION_1_4
+
+/*#ifndef GL_VERSION_1_2
+#define GL_BLEND_EQUATION                                       0x8009
+#define GL_MIN                                                  0x8007
+#define GL_MAX                                                  0x8008
+#define GL_FUNC_ADD                                             0x8006
+#define GL_FUNC_SUBTRACT                                        0x800A
+#define GL_FUNC_REVERSE_SUBTRACT                                0x800B
+#define GL_BLEND_COLOR                                          0x8005
+#define GL_CONSTANT_COLOR                                       0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR                             0x8002
+#define GL_CONSTANT_ALPHA                                       0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA                             0x8004
+#endif *//* GL_VERSION_1_2 */
+
+#define GL_GENERATE_MIPMAP                                      0x8191
+#define GL_GENERATE_MIPMAP_HINT                                 0x8192
+#define GL_DEPTH_COMPONENT16                                    0x81A5
+#define GL_DEPTH_COMPONENT24                                    0x81A6
+#define GL_DEPTH_COMPONENT32                                    0x81A7
+#define GL_TEXTURE_DEPTH_SIZE                                   0x884A
+#define GL_DEPTH_TEXTURE_MODE                                   0x884B
+#define GL_TEXTURE_COMPARE_MODE                                 0x884C
+#define GL_TEXTURE_COMPARE_FUNC                                 0x884D
+#define GL_COMPARE_R_TO_TEXTURE                                 0x884E
+#define GL_FOG_COORDINATE_SOURCE                                0x8450
+#define GL_FOG_COORDINATE                                       0x8451
+#define GL_FRAGMENT_DEPTH                                       0x8452
+#define GL_CURRENT_FOG_COORDINATE                               0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE                            0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE                          0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER                         0x8456
+#define GL_FOG_COORDINATE_ARRAY                                 0x8457
+#define GL_POINT_SIZE_MIN                                       0x8126
+#define GL_POINT_SIZE_MAX                                       0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE                            0x8128
+#define GL_POINT_DISTANCE_ATTENUATION                           0x8129
+#define GL_COLOR_SUM                                            0x8458
+#define GL_CURRENT_SECONDARY_COLOR                              0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE                           0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE                           0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE                         0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER                        0x845D
+#define GL_SECONDARY_COLOR_ARRAY                                0x845E
+#define GL_BLEND_DST_RGB                                        0x80C8
+#define GL_BLEND_SRC_RGB                                        0x80C9
+#define GL_BLEND_DST_ALPHA                                      0x80CA
+#define GL_BLEND_SRC_ALPHA                                      0x80CB
+#define GL_INCR_WRAP                                            0x8507
+#define GL_DECR_WRAP                                            0x8508
+#define GL_TEXTURE_FILTER_CONTROL                               0x8500
+#define GL_TEXTURE_LOD_BIAS                                     0x8501
+#define GL_MAX_TEXTURE_LOD_BIAS                                 0x84FD
+#define GL_GL_MIRRORED_REPEAT                                   0x8370
+
+/*#ifndef GL_VERSION_1_2
+typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode );
+typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
+#endif *//* GL_VERSION_1_2 */
+typedef void (APIENTRY * glFogCoordfPROC) (GLfloat coord);
+typedef void (APIENTRY * glFogCoordfvPROC) (const GLfloat *coord);
+typedef void (APIENTRY * glFogCoorddPROC) (GLdouble coord);
+typedef void (APIENTRY * glFogCoorddvPROC) (const GLdouble *coord);
+typedef void (APIENTRY * glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glMultiDrawArraysPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawElementsPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
+typedef void (APIENTRY * glPointParameterfPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvPROC) (GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * glSecondaryColor3bvPROC) (const GLbyte *v);
+typedef void (APIENTRY * glSecondaryColor3dPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * glSecondaryColor3dvPROC) (const GLdouble *v);
+typedef void (APIENTRY * glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * glSecondaryColor3fvPROC) (const GLfloat *v);
+typedef void (APIENTRY * glSecondaryColor3iPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * glSecondaryColor3ivPROC) (const GLint *v);
+typedef void (APIENTRY * glSecondaryColor3sPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * glSecondaryColor3svPROC) (const GLshort *v);
+typedef void (APIENTRY * glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * glSecondaryColor3ubvPROC) (const GLubyte *v);
+typedef void (APIENTRY * glSecondaryColor3uiPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * glSecondaryColor3uivPROC) (const GLuint *v);
+typedef void (APIENTRY * glSecondaryColor3usPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * glSecondaryColor3usvPROC) (const GLushort *v);
+typedef void (APIENTRY * glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+typedef void (APIENTRY * glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRY * glWindowPos2dPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * glWindowPos2fPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * glWindowPos2iPROC) (GLint x, GLint y);
+typedef void (APIENTRY * glWindowPos2sPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * glWindowPos2dvPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos2fvPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos2ivPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos2svPROC) (const GLshort *p);
+typedef void (APIENTRY * glWindowPos3dPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glWindowPos3iPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glWindowPos3sPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glWindowPos3dvPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos3fvPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos3ivPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos3svPROC) (const GLshort *p);
+
+/*#ifndef GL_VERSION_1_2
+extern glBlendColorPROC glBlendColor;
+extern glBlendEquationPROC glBlendEquation;
+#endif *//* GL_VERSION_1_2 */
+
+#ifdef _WIN32
+
+extern glFogCoordfPROC glFogCoordf;
+extern glFogCoordfvPROC glFogCoordfv;
+extern glFogCoorddPROC glFogCoordd;
+extern glFogCoorddvPROC glFogCoorddv;
+extern glFogCoordPointerPROC glFogCoordPointer;
+extern glMultiDrawArraysPROC glMultiDrawArrays;
+extern glMultiDrawElementsPROC glMultiDrawElements;
+extern glPointParameterfPROC glPointParameterf;
+extern glPointParameterfvPROC glPointParameterfv;
+extern glSecondaryColor3bPROC glSecondaryColor3b;
+extern glSecondaryColor3bvPROC glSecondaryColor3bv;
+extern glSecondaryColor3dPROC glSecondaryColor3d;
+extern glSecondaryColor3dvPROC glSecondaryColor3dv;
+extern glSecondaryColor3fPROC glSecondaryColor3f;
+extern glSecondaryColor3fvPROC glSecondaryColor3fv;
+extern glSecondaryColor3iPROC glSecondaryColor3i;
+extern glSecondaryColor3ivPROC glSecondaryColor3iv;
+extern glSecondaryColor3sPROC glSecondaryColor3s;
+extern glSecondaryColor3svPROC glSecondaryColor3sv;
+extern glSecondaryColor3ubPROC glSecondaryColor3ub;
+extern glSecondaryColor3ubvPROC glSecondaryColor3ubv;
+extern glSecondaryColor3uiPROC glSecondaryColor3ui;
+extern glSecondaryColor3uivPROC glSecondaryColor3uiv;
+extern glSecondaryColor3usPROC glSecondaryColor3us;
+extern glSecondaryColor3usvPROC glSecondaryColor3usv;
+extern glSecondaryColorPointerPROC glSecondaryColorPointer;
+extern glBlendFuncSeparatePROC glBlendFuncSeparate;
+extern glWindowPos2dPROC glWindowPos2d;
+extern glWindowPos2fPROC glWindowPos2f;
+extern glWindowPos2iPROC glWindowPos2i;
+extern glWindowPos2sPROC glWindowPos2s;
+extern glWindowPos2dvPROC glWindowPos2dv;
+extern glWindowPos2fvPROC glWindowPos2fv;
+extern glWindowPos2ivPROC glWindowPos2iv;
+extern glWindowPos2svPROC glWindowPos2sv;
+extern glWindowPos3dPROC glWindowPos3d;
+extern glWindowPos3fPROC glWindowPos3f;
+extern glWindowPos3iPROC glWindowPos3i;
+extern glWindowPos3sPROC glWindowPos3s;
+extern glWindowPos3dvPROC glWindowPos3dv;
+extern glWindowPos3fvPROC glWindowPos3fv;
+extern glWindowPos3ivPROC glWindowPos3iv;
+extern glWindowPos3svPROC glWindowPos3sv;
+
+#else
+
+extern void APIENTRY glFogCoordf (GLfloat coord);
+extern void APIENTRY glFogCoordfv (const GLfloat *coord);
+extern void APIENTRY glFogCoordd (GLdouble coord);
+extern void APIENTRY glFogCoorddv (const GLdouble *coord);
+extern void APIENTRY glFogCoordPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glMultiDrawArrays (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+extern void APIENTRY glMultiDrawElements (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
+extern void APIENTRY glPointParameterf (GLenum pname, GLfloat param);
+extern void APIENTRY glPointParameterfv (GLenum pname, GLfloat *params);
+extern void APIENTRY glSecondaryColor3b (GLbyte red, GLbyte green, GLbyte blue);
+extern void APIENTRY glSecondaryColor3bv (const GLbyte *v);
+extern void APIENTRY glSecondaryColor3d (GLdouble red, GLdouble green, GLdouble blue);
+extern void APIENTRY glSecondaryColor3dv (const GLdouble *v);
+extern void APIENTRY glSecondaryColor3f (GLfloat red, GLfloat green, GLfloat blue);
+extern void APIENTRY glSecondaryColor3fv (const GLfloat *v);
+extern void APIENTRY glSecondaryColor3i (GLint red, GLint green, GLint blue);
+extern void APIENTRY glSecondaryColor3iv (const GLint *v);
+extern void APIENTRY glSecondaryColor3s (GLshort red, GLshort green, GLshort blue);
+extern void APIENTRY glSecondaryColor3sv (const GLshort *v);
+extern void APIENTRY glSecondaryColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+extern void APIENTRY glSecondaryColor3ubv (const GLubyte *v);
+extern void APIENTRY glSecondaryColor3ui (GLuint red, GLuint green, GLuint blue);
+extern void APIENTRY glSecondaryColor3uiv (const GLuint *v);
+extern void APIENTRY glSecondaryColor3us (GLushort red, GLushort green, GLushort blue);
+extern void APIENTRY glSecondaryColor3usv (const GLushort *v);
+extern void APIENTRY glSecondaryColorPointer (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+extern void APIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+extern void APIENTRY glWindowPos2d (GLdouble x, GLdouble y);
+extern void APIENTRY glWindowPos2f (GLfloat x, GLfloat y);
+extern void APIENTRY glWindowPos2i (GLint x, GLint y);
+extern void APIENTRY glWindowPos2s (GLshort x, GLshort y);
+extern void APIENTRY glWindowPos2dv (const GLdouble *p);
+extern void APIENTRY glWindowPos2fv (const GLfloat *p);
+extern void APIENTRY glWindowPos2iv (const GLint *p);
+extern void APIENTRY glWindowPos2sv (const GLshort *p);
+extern void APIENTRY glWindowPos3d (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glWindowPos3f (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glWindowPos3i (GLint x, GLint y, GLint z);
+extern void APIENTRY glWindowPos3s (GLshort x, GLshort y, GLshort z);
+extern void APIENTRY glWindowPos3dv (const GLdouble *p);
+extern void APIENTRY glWindowPos3fv (const GLfloat *p);
+extern void APIENTRY glWindowPos3iv (const GLint *p);
+extern void APIENTRY glWindowPos3sv (const GLshort *p);
+
+#endif /* WIN32 */
+
+#endif /* GL_VERSION_1_4 */
+
+/*-------------------------------------------------------------------*/
+/*------------EXTENSIONS---------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_MULTITEXTURE---------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#define GL_TEXTURE0_ARB                                         0x84C0
+#define GL_TEXTURE1_ARB                                         0x84C1
+#define GL_TEXTURE2_ARB                                         0x84C2
+#define GL_TEXTURE3_ARB                                         0x84C3
+#define GL_TEXTURE4_ARB                                         0x84C4
+#define GL_TEXTURE5_ARB                                         0x84C5
+#define GL_TEXTURE6_ARB                                         0x84C6
+#define GL_TEXTURE7_ARB                                         0x84C7
+#define GL_TEXTURE8_ARB                                         0x84C8
+#define GL_TEXTURE9_ARB                                         0x84C9
+#define GL_TEXTURE10_ARB                                        0x84CA
+#define GL_TEXTURE11_ARB                                        0x84CB
+#define GL_TEXTURE12_ARB                                        0x84CC
+#define GL_TEXTURE13_ARB                                        0x84CD
+#define GL_TEXTURE14_ARB                                        0x84CE
+#define GL_TEXTURE15_ARB                                        0x84CF
+#define GL_TEXTURE16_ARB                                        0x84D0
+#define GL_TEXTURE17_ARB                                        0x84D1
+#define GL_TEXTURE18_ARB                                        0x84D2
+#define GL_TEXTURE19_ARB                                        0x84D3
+#define GL_TEXTURE20_ARB                                        0x84D4
+#define GL_TEXTURE21_ARB                                        0x84D5
+#define GL_TEXTURE22_ARB                                        0x84D6
+#define GL_TEXTURE23_ARB                                        0x84D7
+#define GL_TEXTURE24_ARB                                        0x84D8
+#define GL_TEXTURE25_ARB                                        0x84D9
+#define GL_TEXTURE26_ARB                                        0x84DA
+#define GL_TEXTURE27_ARB                                        0x84DB
+#define GL_TEXTURE28_ARB                                        0x84DC
+#define GL_TEXTURE29_ARB                                        0x84DD
+#define GL_TEXTURE30_ARB                                        0x84DE
+#define GL_TEXTURE31_ARB                                        0x84DF
+#define GL_ACTIVE_TEXTURE_ARB                                   0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB                            0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB                                0x84E2
+
+typedef void (APIENTRY * glActiveTextureARBPROC) (GLenum texture );
+typedef void (APIENTRY * glClientActiveTextureARBPROC) (GLenum texture );
+typedef void (APIENTRY * glMultiTexCoord1dARBPROC) (GLenum target, GLdouble s );
+typedef void (APIENTRY * glMultiTexCoord1dvARBPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord1fARBPROC) (GLenum target, GLfloat s );
+typedef void (APIENTRY * glMultiTexCoord1fvARBPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord1iARBPROC) (GLenum target, GLint s );
+typedef void (APIENTRY * glMultiTexCoord1ivARBPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord1sARBPROC) (GLenum target, GLshort s );
+typedef void (APIENTRY * glMultiTexCoord1svARBPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord2dARBPROC) (GLenum target, GLdouble s, GLdouble t );
+typedef void (APIENTRY * glMultiTexCoord2dvARBPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord2fARBPROC) (GLenum target, GLfloat s, GLfloat t );
+typedef void (APIENTRY * glMultiTexCoord2fvARBPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord2iARBPROC) (GLenum target, GLint s, GLint t );
+typedef void (APIENTRY * glMultiTexCoord2ivARBPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord2sARBPROC) (GLenum target, GLshort s, GLshort t );
+typedef void (APIENTRY * glMultiTexCoord2svARBPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord3dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r );
+typedef void (APIENTRY * glMultiTexCoord3dvARBPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord3fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r );
+typedef void (APIENTRY * glMultiTexCoord3fvARBPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord3iARBPROC) (GLenum target, GLint s, GLint t, GLint r );
+typedef void (APIENTRY * glMultiTexCoord3ivARBPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord3sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r );
+typedef void (APIENTRY * glMultiTexCoord3svARBPROC) (GLenum target, const GLshort *v );
+typedef void (APIENTRY * glMultiTexCoord4dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+typedef void (APIENTRY * glMultiTexCoord4dvARBPROC) (GLenum target, const GLdouble *v );
+typedef void (APIENTRY * glMultiTexCoord4fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+typedef void (APIENTRY * glMultiTexCoord4fvARBPROC) (GLenum target, const GLfloat *v );
+typedef void (APIENTRY * glMultiTexCoord4iARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q );
+typedef void (APIENTRY * glMultiTexCoord4ivARBPROC) (GLenum target, const GLint *v );
+typedef void (APIENTRY * glMultiTexCoord4sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+typedef void (APIENTRY * glMultiTexCoord4svARBPROC) (GLenum target, const GLshort *v );
+
+#ifdef _WIN32
+
+extern glActiveTextureARBPROC glActiveTextureARB;
+extern glClientActiveTextureARBPROC glClientActiveTextureARB;
+extern glMultiTexCoord1dARBPROC glMultiTexCoord1dARB;
+extern glMultiTexCoord1dvARBPROC glMultiTexCoord1dvARB;
+extern glMultiTexCoord1fARBPROC glMultiTexCoord1fARB;
+extern glMultiTexCoord1fvARBPROC glMultiTexCoord1fvARB;
+extern glMultiTexCoord1iARBPROC glMultiTexCoord1iARB;
+extern glMultiTexCoord1ivARBPROC glMultiTexCoord1ivARB;
+extern glMultiTexCoord1sARBPROC glMultiTexCoord1sARB;
+extern glMultiTexCoord1svARBPROC glMultiTexCoord1svARB;
+extern glMultiTexCoord2dARBPROC glMultiTexCoord2dARB;
+extern glMultiTexCoord2dvARBPROC glMultiTexCoord2dvARB;
+extern glMultiTexCoord2fARBPROC glMultiTexCoord2fARB;
+extern glMultiTexCoord2fvARBPROC glMultiTexCoord2fvARB;
+extern glMultiTexCoord2iARBPROC glMultiTexCoord2iARB;
+extern glMultiTexCoord2ivARBPROC glMultiTexCoord2ivARB;
+extern glMultiTexCoord2sARBPROC glMultiTexCoord2sARB;
+extern glMultiTexCoord2svARBPROC glMultiTexCoord2svARB;
+extern glMultiTexCoord3dARBPROC glMultiTexCoord3dARB;
+extern glMultiTexCoord3dvARBPROC glMultiTexCoord3dvARB;
+extern glMultiTexCoord3fARBPROC glMultiTexCoord3fARB;
+extern glMultiTexCoord3fvARBPROC glMultiTexCoord3fvARB;
+extern glMultiTexCoord3iARBPROC glMultiTexCoord3iARB;
+extern glMultiTexCoord3ivARBPROC glMultiTexCoord3ivARB;
+extern glMultiTexCoord3sARBPROC glMultiTexCoord3sARB;
+extern glMultiTexCoord3svARBPROC glMultiTexCoord3svARB;
+extern glMultiTexCoord4dARBPROC glMultiTexCoord4dARB;
+extern glMultiTexCoord4dvARBPROC glMultiTexCoord4dvARB;
+extern glMultiTexCoord4fARBPROC glMultiTexCoord4fARB;
+extern glMultiTexCoord4fvARBPROC glMultiTexCoord4fvARB;
+extern glMultiTexCoord4iARBPROC glMultiTexCoord4iARB;
+extern glMultiTexCoord4ivARBPROC glMultiTexCoord4ivARB;
+extern glMultiTexCoord4sARBPROC glMultiTexCoord4sARB;
+extern glMultiTexCoord4svARBPROC glMultiTexCoord4svARB;
+
+#else
+
+extern void APIENTRY glActiveTextureARB (GLenum texture );
+extern void APIENTRY glClientActiveTextureARB (GLenum texture );
+extern void APIENTRY glMultiTexCoord1dARB (GLenum target, GLdouble s );
+extern void APIENTRY glMultiTexCoord1dvARB (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord1fARB (GLenum target, GLfloat s );
+extern void APIENTRY glMultiTexCoord1fvARB (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord1iARB (GLenum target, GLint s );
+extern void APIENTRY glMultiTexCoord1ivARB (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord1sARB (GLenum target, GLshort s );
+extern void APIENTRY glMultiTexCoord1svARB (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord2dARB (GLenum target, GLdouble s, GLdouble t );
+extern void APIENTRY glMultiTexCoord2dvARB (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord2fARB (GLenum target, GLfloat s, GLfloat t );
+extern void APIENTRY glMultiTexCoord2fvARB (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord2iARB (GLenum target, GLint s, GLint t );
+extern void APIENTRY glMultiTexCoord2ivARB (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord2sARB (GLenum target, GLshort s, GLshort t );
+extern void APIENTRY glMultiTexCoord2svARB (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord3dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r );
+extern void APIENTRY glMultiTexCoord3dvARB (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord3fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r );
+extern void APIENTRY glMultiTexCoord3fvARB (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord3iARB (GLenum target, GLint s, GLint t, GLint r );
+extern void APIENTRY glMultiTexCoord3ivARB (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord3sARB (GLenum target, GLshort s, GLshort t, GLshort r );
+extern void APIENTRY glMultiTexCoord3svARB (GLenum target, const GLshort *v );
+extern void APIENTRY glMultiTexCoord4dARB (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+extern void APIENTRY glMultiTexCoord4dvARB (GLenum target, const GLdouble *v );
+extern void APIENTRY glMultiTexCoord4fARB (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+extern void APIENTRY glMultiTexCoord4fvARB (GLenum target, const GLfloat *v );
+extern void APIENTRY glMultiTexCoord4iARB (GLenum target, GLint s, GLint t, GLint r, GLint q );
+extern void APIENTRY glMultiTexCoord4ivARB (GLenum target, const GLint *v );
+extern void APIENTRY glMultiTexCoord4sARB (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+extern void APIENTRY glMultiTexCoord4svARB (GLenum target, const GLshort *v );
+
+#endif /* WIN32 */
+
+#endif /* GL_ARB_multitexture */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TRANSPOSE_MATRIX-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB                       0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB                      0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB                         0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB                           0x84E6
+
+typedef void (APIENTRY * glLoadTransposeMatrixdARBPROC) (const GLdouble m[16] );
+typedef void (APIENTRY * glLoadTransposeMatrixfARBPROC) (const GLfloat m[16] );
+typedef void (APIENTRY * glMultTransposeMatrixdARBPROC) (const GLdouble m[16] );
+typedef void (APIENTRY * glMultTransposeMatrixfARBPROC) (const GLfloat m[16] );
+
+extern glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB;
+extern glLoadTransposeMatrixdARBPROC glLoadTransposeMatrixdARB;
+extern glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB;
+extern glMultTransposeMatrixdARBPROC glMultTransposeMatrixdARB;
+
+#endif /* GL_ARB_transpose_matrix */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_COMPRESSION--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+
+#define GL_COMPRESSED_ALPHA_ARB                                 0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB                             0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB                       0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB                             0x84EC
+#define GL_COMPRESSED_RGB_ARB                                   0x84ED
+#define GL_COMPRESSED_RGBA_ARB                                  0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB                         0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB                               0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB                               0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB                   0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB                       0x86A3
+
+typedef void (APIENTRY * glCompressedTexImage1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexImage2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexImage3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glCompressedTexSubImage3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data );
+typedef void (APIENTRY * glGetCompressedTexImageARBPROC) (GLenum target, GLint lod, GLvoid *img );
+
+extern glCompressedTexImage3DARBPROC glCompressedTexImage3DARB;
+extern glCompressedTexImage2DARBPROC glCompressedTexImage2DARB;
+extern glCompressedTexImage1DARBPROC glCompressedTexImage1DARB; 
+extern glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB;
+extern glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB;
+extern glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB;
+extern glGetCompressedTexImageARBPROC glGetCompressedTexImageARB;
+
+#endif /* GL_ARB_texture_compression */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_CUBE_MAP-------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+
+#define GL_NORMAL_MAP_ARB                                       0x8511
+#define GL_REFLECTION_MAP_ARB                                   0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB                                 0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB                         0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                      0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                      0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                      0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                      0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                      0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                      0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB                           0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB                        0x851C
+
+#endif /* GL_ARB_texture_cube_map */
+
+/*-------------------------------------------------------------------*/
+/*------------SGIX_SHADOW--------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+
+#define GL_TEXTURE_COMPARE_SGIX                                  0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX                         0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX                                 0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX                                 0x819D
+
+#endif /* GL_SGIX_shadow */
+
+/*-------------------------------------------------------------------*/
+/*------------SGIX_DEPTH_TEXTURE-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+
+#define GL_DEPTH_COMPONENT16_SGIX                                0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX                                0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX                                0x81A7
+
+#endif /* GL_SGIX_depth_texture */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_COMPILED_VERTEX_ARRAY------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT                         0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT                         0x81A9
+
+typedef void (APIENTRY * glLockArraysEXTPROC) (GLint first, GLsizei count);
+typedef void (APIENTRY * glUnlockArraysEXTPROC) ();
+
+extern glLockArraysEXTPROC glLockArraysEXT;
+extern glUnlockArraysEXTPROC glUnlockArraysEXT;
+
+#endif /* GL_EXT_compiled_vertex_array */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_ENV_COMBINE--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_env_combine
+#define GL_ARB_texture_env_combine 1
+
+#define GL_COMBINE_ARB                                          0x8570
+#define GL_COMBINE_RGB_ARB                                      0x8571
+#define GL_COMBINE_ALPHA_ARB                                    0x8572
+#define GL_RGB_SCALE_ARB                                        0x8573
+#define GL_ADD_SIGNED_ARB                                       0x8574
+#define GL_INTERPOLATE_ARB                                      0x8575
+#define GL_CONSTANT_ARB                                         0x8576
+#define GL_PRIMARY_COLOR_ARB                                    0x8577
+#define GL_PREVIOUS_ARB                                         0x8578
+#define GL_SOURCE0_RGB_ARB                                      0x8580
+#define GL_SOURCE1_RGB_ARB                                      0x8581
+#define GL_SOURCE2_RGB_ARB                                      0x8582
+#define GL_SOURCE0_ALPHA_ARB                                    0x8588
+#define GL_SOURCE1_ALPHA_ARB                                    0x8589
+#define GL_SOURCE2_ALPHA_ARB                                    0x858A
+#define GL_OPERAND0_RGB_ARB                                     0x8590
+#define GL_OPERAND1_RGB_ARB                                     0x8591
+#define GL_OPERAND2_RGB_ARB                                     0x8592
+#define GL_OPERAND0_ALPHA_ARB                                   0x8598
+#define GL_OPERAND1_ALPHA_ARB                                   0x8599
+#define GL_OPERAND2_ALPHA_ARB                                   0x859A
+
+#endif /* GL_ARB_texture_env_combine */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_ENV_DOT3-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_env_dot3
+#define GL_ARB_texture_env_dot3 1
+
+#define GL_DOT3_RGB_ARB                                         0x86AE
+#define GL_DOT3_RGBA_ARB                                        0x86AF
+
+#endif /* GL_ARB_texture_env_dot3 */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_BORDER_CLAMP-------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_border_clamp
+#define GL_ARB_texture_border_clamp 1
+
+#define GL_CLAMP_TO_BORDER_ARB                                  0x812D
+
+#endif /* GL_ARB_texture_border_clamp */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_ENV_ADD------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+
+
+#endif /* GL_ARB_texture_env_add */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_SECONDARY_COLOR------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+
+#define GL_COLOR_SUM_EXT                                        0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT                          0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT                       0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT                       0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT                     0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT                    0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT                            0x845E
+
+typedef void (APIENTRY * glSecondaryColor3bEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * glSecondaryColor3bvEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * glSecondaryColor3dEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * glSecondaryColor3dvEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * glSecondaryColor3fEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * glSecondaryColor3fvEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * glSecondaryColor3iEXTPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * glSecondaryColor3ivEXTPROC) (const GLint *v);
+typedef void (APIENTRY * glSecondaryColor3sEXTPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * glSecondaryColor3svEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * glSecondaryColor3ubEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * glSecondaryColor3ubvEXTPROC) (const GLubyte *v);
+typedef void (APIENTRY * glSecondaryColor3uiEXTPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * glSecondaryColor3uivEXTPROC) (const GLuint *v);
+typedef void (APIENTRY * glSecondaryColor3usEXTPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * glSecondaryColor3usvEXTPROC) (const GLushort *v);
+typedef void (APIENTRY * glSecondaryColorPointerEXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+
+extern glSecondaryColor3bEXTPROC glSecondaryColor3bEXT;
+extern glSecondaryColor3bvEXTPROC glSecondaryColor3bvEXT;
+extern glSecondaryColor3dEXTPROC glSecondaryColor3dEXT;
+extern glSecondaryColor3dvEXTPROC glSecondaryColor3dvEXT;
+extern glSecondaryColor3fEXTPROC glSecondaryColor3fEXT;
+extern glSecondaryColor3fvEXTPROC glSecondaryColor3fvEXT;
+extern glSecondaryColor3iEXTPROC glSecondaryColor3iEXT;
+extern glSecondaryColor3ivEXTPROC glSecondaryColor3ivEXT;
+extern glSecondaryColor3sEXTPROC glSecondaryColor3sEXT;
+extern glSecondaryColor3svEXTPROC glSecondaryColor3svEXT;
+extern glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT;
+extern glSecondaryColor3ubvEXTPROC glSecondaryColor3ubvEXT;
+extern glSecondaryColor3uiEXTPROC glSecondaryColor3uiEXT;
+extern glSecondaryColor3uivEXTPROC glSecondaryColor3uivEXT;
+extern glSecondaryColor3usEXTPROC glSecondaryColor3usEXT;
+extern glSecondaryColor3usvEXTPROC glSecondaryColor3usvEXT;
+extern glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT;
+
+#endif /* GL_EXT_secondary_color */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_FOG_COORD------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+
+#define GL_FOG_COORDINATE_SOURCE_EXT                            0x8450
+#define GL_FOG_COORDINATE_EXT                                   0x8451
+#define GL_FRAGMENT_DEPTH_EXT                                   0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT                           0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT                        0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT                      0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT                     0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT                             0x8457
+
+typedef void (APIENTRY * glFogCoordfEXTPROC) (GLfloat coord);
+typedef void (APIENTRY * glFogCoordfvEXTPROC) (const GLfloat *coord);
+typedef void (APIENTRY * glFogCoorddEXTPROC) (GLdouble coord);
+typedef void (APIENTRY * glFogCoorddvEXTPROC) (const GLdouble *coord);
+typedef void (APIENTRY * glFogCoordPointerEXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+
+extern glFogCoordfEXTPROC glFogCoordfEXT;
+extern glFogCoordfvEXTPROC glFogCoordfvEXT;
+extern glFogCoorddEXTPROC glFogCoorddEXT;
+extern glFogCoorddvEXTPROC glFogCoorddvEXT;
+extern glFogCoordPointerEXTPROC glFogCoordPointerEXT;
+
+#endif /* GL_EXT_fog_coord */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_VERTEX_ARRAY_RANGE----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+
+#define GL_VERTEX_ARRAY_RANGE_NV                                0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV                         0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV                          0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV                    0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV                        0x8521
+
+typedef void (APIENTRY * glFlushVertexArrayRangeNVPROC) (void);
+typedef void (APIENTRY * glVertexArrayRangeNVPROC) (GLsizei size, const GLvoid *pointer);
+
+extern glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV;
+extern glVertexArrayRangeNVPROC glVertexArrayRangeNV;
+
+#ifdef _WIN32
+
+typedef void * (APIENTRY * wglAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void (APIENTRY * wglFreeMemoryNVPROC) (void *pointer);
+
+extern wglAllocateMemoryNVPROC wglAllocateMemoryNV;
+extern wglFreeMemoryNVPROC wglFreeMemoryNV;
+
+#else
+
+typedef void * (APIENTRY * glXAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void (APIENTRY * glXFreeMemoryNVPROC) (void *pointer);
+
+extern glXAllocateMemoryNVPROC glXAllocateMemoryNV;
+extern glXFreeMemoryNVPROC glXFreeMemoryNV;
+
+#endif /* WIN32 */
+
+#endif /* GL_NV_vertex_array_range */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_VERTEX_ARRAY_RANGE2---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_vertex_array_range2
+#define GL_NV_vertex_array_range2 1
+
+#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV                  0x8533
+
+#endif /* GL_NV_vertex_array_range2 */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_POINT_PARAMETERS-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+
+#define GL_POINT_SIZE_MIN_EXT                                   0x8126
+#define GL_POINT_SIZE_MAX_EXT                                   0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT                        0x8128
+#define GL_DISTANCE_ATTENUATION_EXT                             0x8129
+
+typedef void (APIENTRY * glPointParameterfEXTPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvEXTPROC) (GLenum pname, const GLfloat *params);
+
+extern glPointParameterfEXTPROC glPointParameterfEXT;
+extern glPointParameterfvEXTPROC glPointParameterfvEXT;
+
+#endif /* GL_EXT_point_parameters */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_REGISTER_COMBINERS----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+
+#define GL_REGISTER_COMBINERS_NV                                0x8522
+#define GL_COMBINER0_NV                                         0x8550
+#define GL_COMBINER1_NV                                         0x8551
+#define GL_COMBINER2_NV                                         0x8552
+#define GL_COMBINER3_NV                                         0x8553
+#define GL_COMBINER4_NV                                         0x8554
+#define GL_COMBINER5_NV                                         0x8555
+#define GL_COMBINER6_NV                                         0x8556
+#define GL_COMBINER7_NV                                         0x8557
+#define GL_VARIABLE_A_NV                                        0x8523
+#define GL_VARIABLE_B_NV                                        0x8524
+#define GL_VARIABLE_C_NV                                        0x8525
+#define GL_VARIABLE_D_NV                                        0x8526
+#define GL_VARIABLE_E_NV                                        0x8527
+#define GL_VARIABLE_F_NV                                        0x8528
+#define GL_VARIABLE_G_NV                                        0x8529
+#define GL_CONSTANT_COLOR0_NV                                   0x852A
+#define GL_CONSTANT_COLOR1_NV                                   0x852B
+#define GL_PRIMARY_COLOR_NV                                     0x852C
+#define GL_SECONDARY_COLOR_NV                                   0x852D
+#define GL_SPARE0_NV                                            0x852E
+#define GL_SPARE1_NV                                            0x852F
+#define GL_UNSIGNED_IDENTITY_NV                                 0x8536
+#define GL_UNSIGNED_INVERT_NV                                   0x8537
+#define GL_EXPAND_NORMAL_NV                                     0x8538
+#define GL_EXPAND_NEGATE_NV                                     0x8539
+#define GL_HALF_BIAS_NORMAL_NV                                  0x853A
+#define GL_HALF_BIAS_NEGATE_NV                                  0x853B
+#define GL_SIGNED_IDENTITY_NV                                   0x853C
+#define GL_SIGNED_NEGATE_NV                                     0x853D
+#define GL_E_TIMES_F_NV                                         0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV                       0x8532
+#define GL_SCALE_BY_TWO_NV                                      0x853E
+#define GL_SCALE_BY_FOUR_NV                                     0x853F
+#define GL_SCALE_BY_ONE_HALF_NV                                 0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV                         0x8541
+#define GL_DISCARD_NV                                           0x8530
+#define GL_COMBINER_INPUT_NV                                    0x8542
+#define GL_COMBINER_MAPPING_NV                                  0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV                          0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV                           0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV                           0x8546
+#define GL_COMBINER_MUX_SUM_NV                                  0x8547
+#define GL_COMBINER_SCALE_NV                                    0x8548
+#define GL_COMBINER_BIAS_NV                                     0x8549
+#define GL_COMBINER_AB_OUTPUT_NV                                0x854A
+#define GL_COMBINER_CD_OUTPUT_NV                                0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV                               0x854C
+#define GL_NUM_GENERAL_COMBINERS_NV                             0x854E
+#define GL_COLOR_SUM_CLAMP_NV                                   0x854F
+#define GL_MAX_GENERAL_COMBINERS_NV                             0x854D
+
+typedef void (APIENTRY * glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glCombinerParameterfNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glCombinerParameterivNVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * glCombinerParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glCombinerInputNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * glCombinerOutputNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRY * glFinalCombinerInputNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * glGetCombinerInputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetCombinerInputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetCombinerOutputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetCombinerOutputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetFinalCombinerInputParameterfvNVPROC) (GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetFinalCombinerInputParameterivNVPROC) (GLenum variable, GLenum pname, GLint *params);
+
+extern glCombinerParameterfvNVPROC glCombinerParameterfvNV;
+extern glCombinerParameterfNVPROC  glCombinerParameterfNV;
+extern glCombinerParameterivNVPROC glCombinerParameterivNV;
+extern glCombinerParameteriNVPROC glCombinerParameteriNV;
+extern glCombinerInputNVPROC glCombinerInputNV;
+extern glCombinerOutputNVPROC glCombinerOutputNV;
+extern glFinalCombinerInputNVPROC glFinalCombinerInputNV;
+extern glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV;
+extern glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV;
+extern glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV;
+extern glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV;
+extern glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV;
+extern glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV;
+
+#endif /* GL_NV_register_combiners */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_MULTISAMPLE----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+
+#define GL_MULTISAMPLE_ARB                                      0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB                         0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB                              0x809F
+#define GL_SAMPLE_COVERAGE_ARB                                  0x80A0
+#define GL_SAMPLE_BUFFERS_ARB                                   0x80A8
+#define GL_SAMPLES_ARB                                          0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB                            0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB                           0x80AB
+#define GL_MULTISAMPLE_BIT_ARB                                  0x20000000
+
+typedef void (APIENTRY * glSampleCoverageARBPROC) (GLclampf value, GLboolean invert );
+
+extern glSampleCoverageARBPROC glSampleCoverageARB;
+
+#endif /* GL_ARB_multisample */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_TEXTURE_SHADER--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texture_shader
+#define GL_NV_texture_shader 1
+
+#define GL_TEXTURE_SHADER_NV                                    0x86DE
+#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV                 0x86D9
+#define GL_SHADER_OPERATION_NV                                  0x86DF
+#define GL_CULL_MODES_NV                                        0x86E0
+#define GL_OFFSET_TEXTURE_MATRIX_NV                             0x86E1
+#define GL_OFFSET_TEXTURE_SCALE_NV                              0x86E2
+#define GL_OFFSET_TEXTURE_BIAS_NV                               0x86E3
+#define GL_PREVIOUS_TEXTURE_INPUT_NV                            0x86E4
+#define GL_CONST_EYE_NV                                         0x86E5
+#define GL_SHADER_CONSISTENT_NV                                 0x86DD
+#define GL_PASS_THROUGH_NV                                      0x86E6
+#define GL_CULL_FRAGMENT_NV                                     0x86E7
+#define GL_OFFSET_TEXTURE_2D_NV                                 0x86E8
+#define GL_OFFSET_TEXTURE_RECTANGLE_NV                          0x864C
+#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV                    0x864D
+#define GL_DEPENDENT_AR_TEXTURE_2D_NV                           0x86E9
+#define GL_DEPENDENT_GB_TEXTURE_2D_NV                           0x86EA
+#define GL_DOT_PRODUCT_NV                                       0x86EC
+#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV                         0x86ED
+#define GL_DOT_PRODUCT_TEXTURE_2D_NV                            0x86EE
+#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV                     0x864E
+#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV                      0x86F0
+#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV                      0x86F1
+#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV                      0x86F2
+#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV            0x86F3
+#define GL_HILO_NV                                              0x86F4
+#define GL_DSDT_NV                                              0x86F5
+#define GL_DSDT_MAG_NV                                          0x86F6
+#define GL_DSDT_MAG_VIB_NV                                      0x86F7
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV                            0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV                        0x86DB
+#define GL_SIGNED_RGBA_NV                                       0x86FB
+#define GL_SIGNED_RGBA8_NV                                      0x86FC
+#define GL_SIGNED_RGB_NV                                        0x86FE
+#define GL_SIGNED_RGB8_NV                                       0x86FF
+#define GL_SIGNED_LUMINANCE_NV                                  0x8701
+#define GL_SIGNED_LUMINANCE8_NV                                 0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV                            0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV                          0x8704
+#define GL_SIGNED_ALPHA_NV                                      0x8705
+#define GL_SIGNED_ALPHA8_NV                                     0x8706
+#define GL_SIGNED_INTENSITY_NV                                  0x8707
+#define GL_SIGNED_INTENSITY8_NV                                 0x8708
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV                         0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV                       0x870D
+#define GL_HILO16_NV                                            0x86F8
+#define GL_SIGNED_HILO_NV                                       0x86F9
+#define GL_SIGNED_HILO16_NV                                     0x86FA
+#define GL_DSDT8_NV                                             0x8709
+#define GL_DSDT8_MAG8_NV                                        0x870A
+#define GL_DSDT_MAG_INTENSITY_NV                                0x86DC
+#define GL_DSDT8_MAG8_INTENSITY8_NV                             0x870B
+#define GL_HI_SCALE_NV                                          0x870E
+#define GL_LO_SCALE_NV                                          0x870F
+#define GL_DS_SCALE_NV                                          0x8710
+#define GL_DT_SCALE_NV                                          0x8711
+#define GL_MAGNITUDE_SCALE_NV                                   0x8712
+#define GL_VIBRANCE_SCALE_NV                                    0x8713
+#define GL_HI_BIAS_NV                                           0x8714
+#define GL_LO_BIAS_NV                                           0x8715
+#define GL_DS_BIAS_NV                                           0x8716
+#define GL_DT_BIAS_NV                                           0x8717
+#define GL_MAGNITUDE_BIAS_NV                                    0x8718
+#define GL_VIBRANCE_BIAS_NV                                     0x8719
+#define GL_TEXTURE_BORDER_VALUES_NV                             0x871A
+#define GL_TEXTURE_HI_SIZE_NV                                   0x871B
+#define GL_TEXTURE_LO_SIZE_NV                                   0x871C
+#define GL_TEXTURE_DS_SIZE_NV                                   0x871D
+#define GL_TEXTURE_DT_SIZE_NV                                   0x871E
+#define GL_TEXTURE_MAG_SIZE_NV                                  0x871F
+
+#endif /* GL_NV_texture_shader */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_TEXTURE_RECTANGLE--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texture_rectangle
+#define GL_NV_texture_rectangle 1
+
+#define GL_TEXTURE_RECTANGLE_NV                                 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_NV                         0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_NV                           0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV                        0x84F8
+
+#endif /* GL_NV_texture_recrangle */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_TEXTURE_ENV_COMBINE4--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+
+#define GL_COMBINE4_NV                                          0x8503
+#define GL_SOURCE3_RGB_NV                                       0x8583
+#define GL_SOURCE3_ALPHA_NV                                     0x858B
+#define GL_OPERAND3_RGB_NV                                      0x8593
+#define GL_OPERAND3_ALPHA_NV                                    0x859B
+
+#endif /* GL_NV_texture_env_combine */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_FOG_DISTANCE----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+
+#define GL_FOG_DISTANCE_MODE_NV                                 0x855A
+#define GL_EYE_RADIAL_NV                                        0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV                                0x855C
+
+#endif /* GL_NV_fog_distance */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_TEXTURE_FILTER_ANISOTROPIC-------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT                           0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT                       0x84FF
+
+#endif /* GL_EXT_texture_filter_anisotropic */
+
+/*-------------------------------------------------------------------*/
+/*------------SGIS_GENERATE_MIPMAP-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+
+#define GL_GENERATE_MIPMAP_SGIS                                 0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS                            0x8192
+
+#endif /* GL_SGIS_generate_mipmap */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_TEXGEN_REFLECTION-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+
+#define GL_NORMAL_MAP_NV                                        0x8511
+#define GL_REFLECTION_MAP_NV                                    0x8512
+
+#endif /* GL_NV_texgen_reflection */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_VERTEX_WEIGHTING-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+
+#define GL_MODELVIEW0_STACK_DEPTH_EXT                           0x0BA3  /* alias to GL_MODELVIEW_STACK_DEPTH */
+#define GL_MODELVIEW1_STACK_DEPTH_EXT                           0x8502
+#define GL_MODELVIEW0_MATRIX_EXT                                0x0BA6  /* alias to GL_MODELVIEW_MATRIX */
+#define GL_MODELVIEW1_MATRIX_EXT                                0x8506
+#define GL_VERTEX_WEIGHTING_EXT                                 0x8509
+#define GL_MODELVIEW0_EXT                                       0x1700  /* alias to GL_MODELVIEW */
+#define GL_MODELVIEW1_EXT                                       0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT                            0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT                              0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT                         0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT                         0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT                       0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT                      0x8510
+
+typedef void (APIENTRY * glVertexWeightfEXTPROC) (GLfloat weight);
+typedef void (APIENTRY * glVertexWeightfvEXTPROC) (const GLfloat *weight);
+typedef void (APIENTRY * glVertexWeightPointerEXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+
+extern glVertexWeightfEXTPROC glVertexWeightfEXT;
+extern glVertexWeightfvEXTPROC glVertexWeightfvEXT;
+extern glVertexWeightPointerEXTPROC glVertexWeightPointerEXT;
+
+#endif /* GL_EXT_vertex_weighting */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_VERTEX_PROGRAM--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_vertex_program
+#define GL_NV_vertex_program 1
+
+#define GL_VERTEX_PROGRAM_NV                                    0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE_NV                         0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_NV                           0x8643
+#define GL_VERTEX_STATE_PROGRAM_NV                              0x8621
+#define GL_ATTRIB_ARRAY_SIZE_NV                                 0x8623
+#define GL_ATTRIB_ARRAY_STRIDE_NV                               0x8624
+#define GL_ATTRIB_ARRAY_TYPE_NV                                 0x8625
+#define GL_CURRENT_ATTRIB_NV                                    0x8626
+#define GL_PROGRAM_PARAMETER_NV                                 0x8644
+#define GL_ATTRIB_ARRAY_POINTER_NV                              0x8645
+#define GL_PROGRAM_TARGET_NV                                    0x8646
+#define GL_PROGRAM_LENGTH_NV                                    0x8627
+#define GL_PROGRAM_RESIDENT_NV                                  0x8647
+#define GL_PROGRAM_STRING_NV                                    0x8628
+#define GL_TRACK_MATRIX_NV                                      0x8648
+#define GL_TRACK_MATRIX_TRANSFORM_NV                            0x8649
+#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV                      0x862E
+#define GL_MAX_TRACK_MATRICES_NV                                0x862F
+#define GL_CURRENT_MATRIX_STACK_DEPTH_NV                        0x8640
+#define GL_CURRENT_MATRIX_NV                                    0x8641
+#define GL_VERTEX_PROGRAM_BINDING_NV                            0x864A
+#define GL_PROGRAM_ERROR_POSITION_NV                            0x864B
+#define GL_MODELVIEW_PROJECTION_NV                              0x8629
+#define GL_MATRIX0_NV                                           0x8630
+#define GL_MATRIX1_NV                                           0x8631
+#define GL_MATRIX2_NV                                           0x8632
+#define GL_MATRIX3_NV                                           0x8633
+#define GL_MATRIX4_NV                                           0x8634
+#define GL_MATRIX5_NV                                           0x8635
+#define GL_MATRIX6_NV                                           0x8636
+#define GL_MATRIX7_NV                                           0x8637
+#define GL_IDENTITY_NV                                          0x862A
+#define GL_INVERSE_NV                                           0x862B
+#define GL_TRANSPOSE_NV                                         0x862C
+#define GL_INVERSE_TRANSPOSE_NV                                 0x862D
+#define GL_VERTEX_ATTRIB_ARRAY0_NV                              0x8650
+#define GL_VERTEX_ATTRIB_ARRAY1_NV                              0x8651
+#define GL_VERTEX_ATTRIB_ARRAY2_NV                              0x8652
+#define GL_VERTEX_ATTRIB_ARRAY3_NV                              0x8653
+#define GL_VERTEX_ATTRIB_ARRAY4_NV                              0x8654
+#define GL_VERTEX_ATTRIB_ARRAY5_NV                              0x8655
+#define GL_VERTEX_ATTRIB_ARRAY6_NV                              0x8656
+#define GL_VERTEX_ATTRIB_ARRAY7_NV                              0x8657
+#define GL_VERTEX_ATTRIB_ARRAY8_NV                              0x8658
+#define GL_VERTEX_ATTRIB_ARRAY9_NV                              0x8659
+#define GL_VERTEX_ATTRIB_ARRAY10_NV                             0x865A
+#define GL_VERTEX_ATTRIB_ARRAY11_NV                             0x865B
+#define GL_VERTEX_ATTRIB_ARRAY12_NV                             0x865C
+#define GL_VERTEX_ATTRIB_ARRAY13_NV                             0x865D
+#define GL_VERTEX_ATTRIB_ARRAY14_NV                             0x865E
+#define GL_VERTEX_ATTRIB_ARRAY15_NV                             0x865F
+#define GL_MAP1_VERTEX_ATTRIB0_4_NV                             0x8660
+#define GL_MAP1_VERTEX_ATTRIB1_4_NV                             0x8661
+#define GL_MAP1_VERTEX_ATTRIB2_4_NV                             0x8662
+#define GL_MAP1_VERTEX_ATTRIB3_4_NV                             0x8663
+#define GL_MAP1_VERTEX_ATTRIB4_4_NV                             0x8664
+#define GL_MAP1_VERTEX_ATTRIB5_4_NV                             0x8665
+#define GL_MAP1_VERTEX_ATTRIB6_4_NV                             0x8666
+#define GL_MAP1_VERTEX_ATTRIB7_4_NV                             0x8667
+#define GL_MAP1_VERTEX_ATTRIB8_4_NV                             0x8668
+#define GL_MAP1_VERTEX_ATTRIB9_4_NV                             0x8669
+#define GL_MAP1_VERTEX_ATTRIB10_4_NV                            0x866A
+#define GL_MAP1_VERTEX_ATTRIB11_4_NV                            0x866B
+#define GL_MAP1_VERTEX_ATTRIB12_4_NV                            0x866C
+#define GL_MAP1_VERTEX_ATTRIB13_4_NV                            0x866D
+#define GL_MAP1_VERTEX_ATTRIB14_4_NV                            0x866E
+#define GL_MAP1_VERTEX_ATTRIB15_4_NV                            0x866F
+#define GL_MAP2_VERTEX_ATTRIB0_4_NV                             0x8670
+#define GL_MAP2_VERTEX_ATTRIB1_4_NV                             0x8671
+#define GL_MAP2_VERTEX_ATTRIB2_4_NV                             0x8672
+#define GL_MAP2_VERTEX_ATTRIB3_4_NV                             0x8673
+#define GL_MAP2_VERTEX_ATTRIB4_4_NV                             0x8674
+#define GL_MAP2_VERTEX_ATTRIB5_4_NV                             0x8675
+#define GL_MAP2_VERTEX_ATTRIB6_4_NV                             0x8676
+#define GL_MAP2_VERTEX_ATTRIB7_4_NV                             0x8677
+#define GL_MAP2_VERTEX_ATTRIB8_4_NV                             0x8678
+#define GL_MAP2_VERTEX_ATTRIB9_4_NV                             0x8679
+#define GL_MAP2_VERTEX_ATTRIB10_4_NV                            0x867A
+#define GL_MAP2_VERTEX_ATTRIB11_4_NV                            0x867B
+#define GL_MAP2_VERTEX_ATTRIB12_4_NV                            0x867C
+#define GL_MAP2_VERTEX_ATTRIB13_4_NV                            0x867D
+#define GL_MAP2_VERTEX_ATTRIB14_4_NV                            0x867E
+#define GL_MAP2_VERTEX_ATTRIB15_4_NV                            0x867F
+
+typedef void (APIENTRY * glBindProgramNVPROC) (GLenum target, GLuint id);
+typedef void (APIENTRY * glDeleteProgramsNVPROC) (GLsizei n, const GLuint *ids);
+typedef void (APIENTRY * glExecuteProgramNVPROC) (GLenum target, GLuint id, const GLfloat *params);
+typedef void (APIENTRY * glGenProgramsNVPROC) (GLsizei n, GLuint *ids);
+typedef GLboolean (APIENTRY * glAreProgramsResidentNVPROC) (GLsizei n, const GLuint *ids, GLboolean *residences);
+typedef void (APIENTRY * glRequestResidentProgramsNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRY * glGetProgramParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetProgramParameterdvNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetProgramivNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetProgramStringNVPROC) (GLuint id, GLenum pname, GLubyte *program);
+typedef void (APIENTRY * glGetTrackMatrixivNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribdvNVPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetVertexAttribfvNVPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVertexAttribivNVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribPointervNVPROC) (GLuint index, GLenum pname, GLvoid **pointer);
+typedef GLboolean (APIENTRY * glIsProgramNVPROC) (GLuint id);
+typedef void (APIENTRY * glLoadProgramNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
+typedef void (APIENTRY * glProgramParameter4fNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramParameter4dNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramParameter4dvNVPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramParameter4fvNVPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glProgramParameters4dvNVPROC) (GLenum target, GLuint index, GLuint num, const GLdouble *params);
+typedef void (APIENTRY * glProgramParameters4fvNVPROC) (GLenum target, GLuint index, GLuint num, const GLfloat *params);
+typedef void (APIENTRY * glTrackMatrixNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
+typedef void (APIENTRY * glVertexAttribPointerNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glVertexAttrib1sNVPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * glVertexAttrib1fNVPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * glVertexAttrib1dNVPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * glVertexAttrib2sNVPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexAttrib2fNVPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexAttrib2dNVPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexAttrib3sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexAttrib3fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexAttrib3dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexAttrib4sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexAttrib4fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexAttrib4dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexAttrib4ubNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * glVertexAttrib1svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib1fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib1dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib2svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib2fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib2dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib3svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib3fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib3dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib4dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4ubvNVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttribs1svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs1fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs1dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs2svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs2fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs2dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs3svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs3fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs3dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs4svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs4fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs4dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs4ubvNVPROC) (GLuint index, GLsizei n, const GLubyte *v);
+
+extern glBindProgramNVPROC glBindProgramNV;
+extern glDeleteProgramsNVPROC glDeleteProgramsNV;
+extern glExecuteProgramNVPROC glExecuteProgramNV;
+extern glGenProgramsNVPROC glGenProgramsNV;
+extern glAreProgramsResidentNVPROC glAreProgramsResidentNV;
+extern glRequestResidentProgramsNVPROC glRequestResidentProgramsNV;
+extern glGetProgramParameterfvNVPROC glGetProgramParameterfvNV;
+extern glGetProgramParameterdvNVPROC glGetProgramParameterdvNV;
+extern glGetProgramivNVPROC glGetProgramivNV;
+extern glGetProgramStringNVPROC glGetProgramStringNV;
+extern glGetTrackMatrixivNVPROC glGetTrackMatrixivNV;
+extern glGetVertexAttribdvNVPROC glGetVertexAttribdvNV;
+extern glGetVertexAttribfvNVPROC glGetVertexAttribfvNV;
+extern glGetVertexAttribivNVPROC glGetVertexAttribivNV;
+extern glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV;
+extern glIsProgramNVPROC glIsProgramNV;
+extern glLoadProgramNVPROC glLoadProgramNV;
+extern glProgramParameter4fNVPROC glProgramParameter4fNV;
+extern glProgramParameter4dNVPROC glProgramParameter4dNV;
+extern glProgramParameter4dvNVPROC glProgramParameter4dvNV;
+extern glProgramParameter4fvNVPROC glProgramParameter4fvNV;
+extern glProgramParameters4dvNVPROC glProgramParameters4dvNV;
+extern glProgramParameters4fvNVPROC glProgramParameters4fvNV;
+extern glTrackMatrixNVPROC glTrackMatrixNV;
+extern glVertexAttribPointerNVPROC glVertexAttribPointerNV;
+extern glVertexAttrib1sNVPROC glVertexAttrib1sNV;
+extern glVertexAttrib1fNVPROC glVertexAttrib1fNV;
+extern glVertexAttrib1dNVPROC glVertexAttrib1dNV;
+extern glVertexAttrib2sNVPROC glVertexAttrib2sNV;
+extern glVertexAttrib2fNVPROC glVertexAttrib2fNV;
+extern glVertexAttrib2dNVPROC glVertexAttrib2dNV;
+extern glVertexAttrib3sNVPROC glVertexAttrib3sNV;
+extern glVertexAttrib3fNVPROC glVertexAttrib3fNV;
+extern glVertexAttrib3dNVPROC glVertexAttrib3dNV;
+extern glVertexAttrib4sNVPROC glVertexAttrib4sNV;
+extern glVertexAttrib4fNVPROC glVertexAttrib4fNV;
+extern glVertexAttrib4dNVPROC glVertexAttrib4dNV;
+extern glVertexAttrib4ubNVPROC glVertexAttrib4ubNV;
+extern glVertexAttrib1svNVPROC glVertexAttrib1svNV;
+extern glVertexAttrib1fvNVPROC glVertexAttrib1fvNV;
+extern glVertexAttrib1dvNVPROC glVertexAttrib1dvNV;
+extern glVertexAttrib2svNVPROC glVertexAttrib2svNV;
+extern glVertexAttrib2fvNVPROC glVertexAttrib2fvNV;
+extern glVertexAttrib2dvNVPROC glVertexAttrib2dvNV;
+extern glVertexAttrib3svNVPROC glVertexAttrib3svNV;
+extern glVertexAttrib3fvNVPROC glVertexAttrib3fvNV;
+extern glVertexAttrib3dvNVPROC glVertexAttrib3dvNV;
+extern glVertexAttrib4svNVPROC glVertexAttrib4svNV;
+extern glVertexAttrib4fvNVPROC glVertexAttrib4fvNV;
+extern glVertexAttrib4dvNVPROC glVertexAttrib4dvNV;
+extern glVertexAttrib4ubvNVPROC glVertexAttrib4ubvNV;
+extern glVertexAttribs1svNVPROC glVertexAttribs1svNV;
+extern glVertexAttribs1fvNVPROC glVertexAttribs1fvNV;
+extern glVertexAttribs1dvNVPROC glVertexAttribs1dvNV;
+extern glVertexAttribs2svNVPROC glVertexAttribs2svNV;
+extern glVertexAttribs2fvNVPROC glVertexAttribs2fvNV;
+extern glVertexAttribs2dvNVPROC glVertexAttribs2dvNV;
+extern glVertexAttribs3svNVPROC glVertexAttribs3svNV;
+extern glVertexAttribs3fvNVPROC glVertexAttribs3fvNV;
+extern glVertexAttribs3dvNVPROC glVertexAttribs3dvNV;
+extern glVertexAttribs4svNVPROC glVertexAttribs4svNV;
+extern glVertexAttribs4fvNVPROC glVertexAttribs4fvNV;
+extern glVertexAttribs4dvNVPROC glVertexAttribs4dvNV;
+extern glVertexAttribs4ubvNVPROC glVertexAttribs4ubvNV;
+
+#endif /* GL_NV_vertex_program */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_FENCE-----------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_fence
+#define GL_NV_fence 1
+
+#define GL_ALL_COMPLETED_NV                                     0x84F2
+#define GL_FENCE_STATUS_NV                                      0x84F3
+#define GL_FENCE_CONDITION_NV                                   0x84F4
+
+typedef void (APIENTRY * glGenFencesNVPROC) (GLsizei n, GLuint *fences);
+typedef void (APIENTRY * glDeleteFencesNVPROC) (GLsizei n, const GLuint *fences);
+typedef void (APIENTRY * glSetFenceNVPROC) (GLuint fence, GLenum condition);
+typedef GLboolean (APIENTRY * glTestFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY * glFinishFenceNVPROC) (GLuint fence);
+typedef GLboolean (APIENTRY * glIsFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY * glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint *params);
+
+extern glGenFencesNVPROC glGenFencesNV;
+extern glDeleteFencesNVPROC glDeleteFencesNV;
+extern glSetFenceNVPROC glSetFenceNV;
+extern glTestFenceNVPROC glTestFenceNV;
+extern glFinishFenceNVPROC glFinishFenceNV;
+extern glIsFenceNVPROC glIsFenceNV;
+extern glGetFenceivNVPROC glGetFenceivNV;
+
+#endif /* GL_NV_fence */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_TEXTURE_SHADER2-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texture_shader2
+#define GL_NV_texture_shader2
+
+#define GL_DOT_PRODUCT_TEXTURE_3D_NV                            0x86EF
+#define GL_HILO_NV                                              0x86F4
+#define GL_DSDT_NV                                              0x86F5
+#define GL_DSDT_MAG_NV                                          0x86F6
+#define GL_DSDT_MAG_VIB_NV                                      0x86F7
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV                            0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV                        0x86DB
+#define GL_SIGNED_RGBA_NV                                       0x86FB
+#define GL_SIGNED_RGBA8_NV                                      0x86FC
+#define GL_SIGNED_RGB_NV                                        0x86FE
+#define GL_SIGNED_RGB8_NV                                       0x86FF
+#define GL_SIGNED_LUMINANCE_NV                                  0x8701
+#define GL_SIGNED_LUMINANCE8_NV                                 0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV                            0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV                          0x8704
+#define GL_SIGNED_ALPHA_NV                                      0x8705
+#define GL_SIGNED_ALPHA8_NV                                     0x8706
+#define GL_SIGNED_INTENSITY_NV                                  0x8707
+#define GL_SIGNED_INTENSITY8_NV                                 0x8708
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV                         0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV                       0x870D
+#define GL_HILO16_NV                                            0x86F8
+#define GL_SIGNED_HILO_NV                                       0x86F9
+#define GL_SIGNED_HILO16_NV                                     0x86FA
+#define GL_DSDT8_NV                                             0x8709
+#define GL_DSDT8_MAG8_NV                                        0x870A
+#define GL_DSDT_MAG_INTENSITY_NV                                0x86DC
+#define GL_DSDT8_MAG8_INTENSITY8_NV                             0x870B 
+
+#endif /* GL_NV_texture_shader2 */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_BLEND_SQUARE----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+
+#endif /* GL_NV_blend_square */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_LIGHT_MAX_EXPONENT----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+
+#define GL_MAX_SHININESS_NV                                     0x8504
+#define GL_MAX_SPOT_EXPONENT_NV                                 0x8505
+
+#endif /* GL_NV_light_max_exponent */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_PACKED_DEPTH_STENCIL--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_packed_depth_stencil
+#define GL_NV_packed_depth_stencil 1
+
+#define GL_DEPTH_STENCIL_NV                                     0x84F9
+#define GL_UNSIGNED_INT_24_8_NV                                 0x84FA
+
+#endif /* GL_NV_packed_depth_stencil */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_REGISTER_COMBINERS2---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_register_combiners2
+#define GL_NV_register_combiners2
+
+#define GL_PER_STAGE_CONSTANTS_NV                               0x8535
+
+typedef void (APIENTRY * glCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glGetCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, GLfloat *params);
+
+extern glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV;
+extern glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV;
+
+#endif /* GL_NV_register_combiners2 */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_ABGR-----------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+
+#define GL_ABGR_EXT                                             0x8000
+
+#endif /* GL_EXT_abgr */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_STENCIL_WRAP---------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+
+#define GL_INCR_WRAP_EXT                                        0x8507
+#define GL_DECR_WRAP_EXT                                        0x8508
+
+#endif /* GL_EXT_stencil_wrap */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_TEXTURE_LOD_BIAS-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+
+#define GL_TEXTURE_FILTER_CONTROL_EXT                           0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT                                 0x8501
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT                             0x84FD
+
+#endif /* GL_EXT_texture_lod_bias */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_EVALUATORS------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_evaluators
+#define GL_NV_evaluators 1
+
+#define GL_EVAL_2D_NV                                           0x86C0
+#define GL_EVAL_TRIANGULAR_2D_NV                                0x86C1
+#define GL_MAP_TESSELLATION_NV                                  0x86C2
+#define GL_MAP_ATTRIB_U_ORDER_NV                                0x86C3
+#define GL_MAP_ATTRIB_V_ORDER_NV                                0x86C4
+#define GL_EVAL_FRACTIONAL_TESSELLATION_NV                      0x86C5
+#define GL_EVAL_VERTEX_ATTRIB0_NV                               0x86C6
+#define GL_EVAL_VERTEX_ATTRIB1_NV                               0x86C7
+#define GL_EVAL_VERTEX_ATTRIB2_NV                               0x86C8
+#define GL_EVAL_VERTEX_ATTRIB3_NV                               0x86C9
+#define GL_EVAL_VERTEX_ATTRIB4_NV                               0x86CA
+#define GL_EVAL_VERTEX_ATTRIB5_NV                               0x86CB
+#define GL_EVAL_VERTEX_ATTRIB6_NV                               0x86CC
+#define GL_EVAL_VERTEX_ATTRIB7_NV                               0x86CD
+#define GL_EVAL_VERTEX_ATTRIB8_NV                               0x86CE
+#define GL_EVAL_VERTEX_ATTRIB9_NV                               0x86CF
+#define GL_EVAL_VERTEX_ATTRIB10_NV                              0x86D0
+#define GL_EVAL_VERTEX_ATTRIB11_NV                              0x86D1
+#define GL_EVAL_VERTEX_ATTRIB12_NV                              0x86D2
+#define GL_EVAL_VERTEX_ATTRIB13_NV                              0x86D3
+#define GL_EVAL_VERTEX_ATTRIB14_NV                              0x86D4
+#define GL_EVAL_VERTEX_ATTRIB15_NV                              0x86D5
+#define GL_MAX_MAP_TESSELLATION_NV                              0x86D6
+#define GL_MAX_RATIONAL_EVAL_ORDER_NV                           0x86D7
+
+typedef void (APIENTRY * glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
+typedef void (APIENTRY * glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
+typedef void (APIENTRY * glGetMapParameterivNVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glEvalMapsNVPROC) (GLenum target, GLenum mode);
+
+extern glMapControlPointsNVPROC glMapControlPointsNV;
+extern glMapParameterivNVPROC glMapParameterivNV;
+extern glMapParameterfvNVPROC glMapParameterfvNV;
+extern glGetMapControlPointsNVPROC glGetMapControlPointsNV;
+extern glGetMapParameterivNVPROC glGetMapParameterivNV;
+extern glGetMapParameterfvNVPROC glGetMapParameterfvNV;
+extern glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV;
+extern glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV;
+extern glEvalMapsNVPROC glEvalMapsNV;
+
+#endif /* GL_NV_evaluators */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_COPY_DEPTH_TO_COLOR---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_copy_depth_to_color
+#define GL_NV_copy_depth_to_color 1
+
+#define GL_DEPTH_STENCIL_TO_RGBA_NV                             0x886E
+#define GL_DEPTH_STENCIL_TO_BGRA_NV                             0x886F
+
+#endif /* GL_NV_copy_depth_to_color */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_PN_TRIANGLES---------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_pn_triangles
+#define GL_ATI_pn_triangles 1
+
+#define GL_PN_TRIANGLES_ATI                                     0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI               0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI                          0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI                         0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI                   0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI                   0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI                    0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI                  0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI               0x87F8
+
+typedef void (APIENTRY * glPNTrianglesiATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glPNTrianglesfATIPROC) (GLenum pname, GLfloat param);
+
+extern glPNTrianglesiATIPROC glPNTrianglesiATI;
+extern glPNTrianglesfATIPROC glPNTrianglesfATI;
+
+#endif /* GL_ATI_pn_triangles */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_POINT_PARAMETERS-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_point_parameters
+#define GL_ARB_point_parameters 1
+
+#define GL_POINT_SIZE_MIN_ARB                                   0x8126
+#define GL_POINT_SIZE_MAX_ARB                                   0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_ARB                        0x8128
+#define GL_POINT_DISTANCE_ATTENUATION_ARB                       0x8129
+
+typedef void (APIENTRY * glPointParameterfARBPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvARBPROC) (GLenum pname, GLfloat *params);
+
+extern glPointParameterfARBPROC glPointParameterfARB;
+extern glPointParameterfvARBPROC glPointParameterfvARB;
+
+#endif /* GL_ARB_point_parameters */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_ENV_CROSSBAR-------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_env_crossbar
+#define GL_ARB_texture_env_crossbar 1
+
+#endif
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_VERTEX_BLEND---------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_vertex_blend
+#define GL_ARB_vertex_blend 1
+
+#define GL_MAX_VERTEX_UNITS_ARB                                 0x86A4
+#define GL_ACTIVE_VERTEX_UNITS_ARB                              0x86A5
+#define GL_WEIGHT_SUM_UNITY_ARB                                 0x86A6      
+#define GL_VERTEX_BLEND_ARB                                     0x86A7
+#define GL_CURRENT_WEIGHT_ARB                                   0x86A8
+#define GL_WEIGHT_ARRAY_TYPE_ARB                                0x86A9
+#define GL_WEIGHT_ARRAY_STRIDE_ARB                              0x86AA
+#define GL_WEIGHT_ARRAY_SIZE_ARB                                0x86AB
+#define GL_WEIGHT_ARRAY_POINTER_ARB                             0x86AC
+#define GL_WEIGHT_ARRAY_ARB                                     0x86AD
+#define GL_MODELVIEW0_ARB                                       0x1700
+#define GL_MODELVIEW1_ARB                                       0x850A
+#define GL_MODELVIEW2_ARB                                       0x8722
+#define GL_MODELVIEW3_ARB                                       0x8723
+#define GL_MODELVIEW4_ARB                                       0x8724
+#define GL_MODELVIEW5_ARB                                       0x8725
+#define GL_MODELVIEW6_ARB                                       0x8726
+#define GL_MODELVIEW7_ARB                                       0x8727
+#define GL_MODELVIEW8_ARB                                       0x8728
+#define GL_MODELVIEW9_ARB                                       0x8729
+#define GL_MODELVIEW10_ARB                                      0x872A
+#define GL_MODELVIEW11_ARB                                      0x872B
+#define GL_MODELVIEW12_ARB                                      0x872C
+#define GL_MODELVIEW13_ARB                                      0x872D
+#define GL_MODELVIEW14_ARB                                      0x872E
+#define GL_MODELVIEW15_ARB                                      0x872F
+#define GL_MODELVIEW16_ARB                                      0x8730
+#define GL_MODELVIEW17_ARB                                      0x8731
+#define GL_MODELVIEW18_ARB                                      0x8732
+#define GL_MODELVIEW19_ARB                                      0x8733
+#define GL_MODELVIEW20_ARB                                      0x8734
+#define GL_MODELVIEW21_ARB                                      0x8735
+#define GL_MODELVIEW22_ARB                                      0x8736
+#define GL_MODELVIEW23_ARB                                      0x8737
+#define GL_MODELVIEW24_ARB                                      0x8738
+#define GL_MODELVIEW25_ARB                                      0x8739
+#define GL_MODELVIEW26_ARB                                      0x873A
+#define GL_MODELVIEW27_ARB                                      0x873B
+#define GL_MODELVIEW28_ARB                                      0x873C
+#define GL_MODELVIEW29_ARB                                      0x873D
+#define GL_MODELVIEW30_ARB                                      0x873E
+#define GL_MODELVIEW31_ARB                                      0x873F
+
+typedef void (APIENTRY * glWeightbvARBPROC) (GLint size, GLbyte *weights);
+typedef void (APIENTRY * glWeightsvARBPROC) (GLint size, GLshort *weights);
+typedef void (APIENTRY * glWeightivARBPROC) (GLint size, GLint *weights);
+typedef void (APIENTRY * glWeightfvARBPROC) (GLint size, GLfloat *weights);
+typedef void (APIENTRY * glWeightdvARBPROC) (GLint size, GLdouble *weights);
+typedef void (APIENTRY * glWeightubvARBPROC) (GLint size, GLubyte *weights);
+typedef void (APIENTRY * glWeightusvARBPROC) (GLint size, GLushort *weights);
+typedef void (APIENTRY * glWeightuivARBPROC) (GLint size, GLuint *weights);
+typedef void (APIENTRY * glWeightPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+typedef void (APIENTRY * glVertexBlendARBPROC) (GLint count);
+
+extern glWeightbvARBPROC glWeightbvARB;
+extern glWeightsvARBPROC glWeightsvARB;
+extern glWeightivARBPROC glWeightivARB;
+extern glWeightfvARBPROC glWeightfvARB;
+extern glWeightdvARBPROC glWeightdvARB;
+extern glWeightubvARBPROC glWeightubvARB;
+extern glWeightusvARBPROC glWeightusvARB;
+extern glWeightuivARBPROC glWeightuivARB;
+extern glWeightPointerARBPROC glWeightPointerARB;
+extern glVertexBlendARBPROC glVertexBlendARB;
+
+#endif /* GL_ARB_vertex_blend */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_MULTI_DRAW_ARRAYS----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+
+typedef void (APIENTRY * glMultiDrawArraysEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawElementsEXTPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
+
+extern glMultiDrawArraysEXTPROC glMultiDrawArraysEXT;
+extern glMultiDrawElementsEXTPROC glMultiDrawElementsEXT;
+
+#endif /* GL_EXT_multi_draw_arrays */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_MATRIX_PALETTE-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_matrix_palette
+#define GL_ARB_matrix_palette 1
+
+#define GL_MATRIX_PALETTE_ARB                                   0x8840
+#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB                   0x8841
+#define GL_MAX_PALETTE_MATRICES_ARB                             0x8842
+#define GL_CURRENT_PALETTE_MATRIX_ARB                           0x8843
+#define GL_MATRIX_INDEX_ARRAY_ARB                               0x8844
+#define GL_CURRENT_MATRIX_INDEX_ARB                             0x8845
+#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB                          0x8846
+#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB                          0x8847
+#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB                        0x8848
+#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB                       0x8849
+
+typedef void (APIENTRY * glCurrentPaletteMatrixARBPROC) (GLint index);
+typedef void (APIENTRY * glMatrixIndexubvARBPROC) (GLint size, GLubyte *indices);
+typedef void (APIENTRY * glMatrixIndexusvARBPROC) (GLint size, GLushort *indices);
+typedef void (APIENTRY * glMatrixIndexuivARBPROC) (GLint size, GLuint *indices);
+typedef void (APIENTRY * glMatrixIndexPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+
+extern glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB;
+extern glMatrixIndexubvARBPROC glMatrixIndexubvARB;
+extern glMatrixIndexusvARBPROC glMatrixIndexusvARB;
+extern glMatrixIndexuivARBPROC glMatrixIndexuivARB;
+extern glMatrixIndexPointerARBPROC glMatrixIndexPointerARB;
+
+#endif /* GL_ARB_matrix_palette */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_VERTEX_SHADER--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_vertex_shader
+#define GL_EXT_vertex_shader 1
+
+#define GL_VERTEX_SHADER_EXT                                    0x8780
+#define GL_VERTEX_SHADER_BINDING_EXT                            0x8781
+#define GL_OP_INDEX_EXT                                         0x8782
+#define GL_OP_NEGATE_EXT                                        0x8783
+#define GL_OP_DOT3_EXT                                          0x8784
+#define GL_OP_DOT4_EXT                                          0x8785
+#define GL_OP_MUL_EXT                                           0x8786
+#define GL_OP_ADD_EXT                                           0x8787
+#define GL_OP_MADD_EXT                                          0x8788
+#define GL_OP_FRAC_EXT                                          0x8789
+#define GL_OP_MAX_EXT                                           0x878A
+#define GL_OP_MIN_EXT                                           0x878B
+#define GL_OP_SET_GE_EXT                                        0x878C
+#define GL_OP_SET_LT_EXT                                        0x878D
+#define GL_OP_CLAMP_EXT                                         0x878E
+#define GL_OP_FLOOR_EXT                                         0x878F
+#define GL_OP_ROUND_EXT                                         0x8790
+#define GL_OP_EXP_BASE_2_EXT                                    0x8791
+#define GL_OP_LOG_BASE_2_EXT                                    0x8792
+#define GL_OP_POWER_EXT                                         0x8793
+#define GL_OP_RECIP_EXT                                         0x8794
+#define GL_OP_RECIP_SQRT_EXT                                    0x8795
+#define GL_OP_SUB_EXT                                           0x8796
+#define GL_OP_CROSS_PRODUCT_EXT                                 0x8797
+#define GL_OP_MULTIPLY_MATRIX_EXT                               0x8798
+#define GL_OP_MOV_EXT                                           0x8799
+#define GL_OUTPUT_VERTEX_EXT                                    0x879A
+#define GL_OUTPUT_COLOR0_EXT                                    0x879B
+#define GL_OUTPUT_COLOR1_EXT                                    0x879C
+#define GL_OUTPUT_TEXTURE_COORD0_EXT                            0x879D
+#define GL_OUTPUT_TEXTURE_COORD1_EXT                            0x879E
+#define GL_OUTPUT_TEXTURE_COORD2_EXT                            0x879F
+#define GL_OUTPUT_TEXTURE_COORD3_EXT                            0x87A0
+#define GL_OUTPUT_TEXTURE_COORD4_EXT                            0x87A1
+#define GL_OUTPUT_TEXTURE_COORD5_EXT                            0x87A2
+#define GL_OUTPUT_TEXTURE_COORD6_EXT                            0x87A3
+#define GL_OUTPUT_TEXTURE_COORD7_EXT                            0x87A4
+#define GL_OUTPUT_TEXTURE_COORD8_EXT                            0x87A5
+#define GL_OUTPUT_TEXTURE_COORD9_EXT                            0x87A6
+#define GL_OUTPUT_TEXTURE_COORD10_EXT                           0x87A7
+#define GL_OUTPUT_TEXTURE_COORD11_EXT                           0x87A8
+#define GL_OUTPUT_TEXTURE_COORD12_EXT                           0x87A9
+#define GL_OUTPUT_TEXTURE_COORD13_EXT                           0x87AA
+#define GL_OUTPUT_TEXTURE_COORD14_EXT                           0x87AB
+#define GL_OUTPUT_TEXTURE_COORD15_EXT                           0x87AC
+#define GL_OUTPUT_TEXTURE_COORD16_EXT                           0x87AD
+#define GL_OUTPUT_TEXTURE_COORD17_EXT                           0x87AE
+#define GL_OUTPUT_TEXTURE_COORD18_EXT                           0x87AF
+#define GL_OUTPUT_TEXTURE_COORD19_EXT                           0x87B0
+#define GL_OUTPUT_TEXTURE_COORD20_EXT                           0x87B1
+#define GL_OUTPUT_TEXTURE_COORD21_EXT                           0x87B2
+#define GL_OUTPUT_TEXTURE_COORD22_EXT                           0x87B3
+#define GL_OUTPUT_TEXTURE_COORD23_EXT                           0x87B4
+#define GL_OUTPUT_TEXTURE_COORD24_EXT                           0x87B5
+#define GL_OUTPUT_TEXTURE_COORD25_EXT                           0x87B6
+#define GL_OUTPUT_TEXTURE_COORD26_EXT                           0x87B7
+#define GL_OUTPUT_TEXTURE_COORD27_EXT                           0x87B8
+#define GL_OUTPUT_TEXTURE_COORD28_EXT                           0x87B9
+#define GL_OUTPUT_TEXTURE_COORD29_EXT                           0x87BA
+#define GL_OUTPUT_TEXTURE_COORD30_EXT                           0x87BB
+#define GL_OUTPUT_TEXTURE_COORD31_EXT                           0x87BC
+#define GL_OUTPUT_FOG_EXT                                       0x87BD
+#define GL_SCALAR_EXT                                           0x87BE
+#define GL_VECTOR_EXT                                           0x87BF
+#define GL_MATRIX_EXT                                           0x87C0
+#define GL_VARIANT_EXT                                          0x87C1
+#define GL_INVARIANT_EXT                                        0x87C2
+#define GL_LOCAL_CONSTANT_EXT                                   0x87C3
+#define GL_LOCAL_EXT                                            0x87C4
+#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT                   0x87C5
+#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT                       0x87C6
+#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT                     0x87C7
+#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                0x87C8
+#define GL_MAX_VERTEX_SHADER_LOCALS_EXT                         0x87C9
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT         0x87CA
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT             0x87CB
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT           0x87CC
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT      0x87CD
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT               0x87CE
+#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT                       0x87CF
+#define GL_VERTEX_SHADER_VARIANTS_EXT                           0x87D0
+#define GL_VERTEX_SHADER_INVARIANTS_EXT                         0x87D1
+#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                    0x87D2
+#define GL_VERTEX_SHADER_LOCALS_EXT                             0x87D3
+#define GL_VERTEX_SHADER_OPTIMIZED_EXT                          0x87D4
+#define GL_X_EXT                                                0x87D5
+#define GL_Y_EXT                                                0x87D6
+#define GL_Z_EXT                                                0x87D7
+#define GL_W_EXT                                                0x87D8
+#define GL_NEGATIVE_X_EXT                                       0x87D9
+#define GL_NEGATIVE_Y_EXT                                       0x87DA
+#define GL_NEGATIVE_Z_EXT                                       0x87DB
+#define GL_NEGATIVE_W_EXT                                       0x87DC
+#define GL_ZERO_EXT                                             0x87DD
+#define GL_ONE_EXT                                              0x87DE
+#define GL_NEGATIVE_ONE_EXT                                     0x87DF
+#define GL_NORMALIZED_RANGE_EXT                                 0x87E0
+#define GL_FULL_RANGE_EXT                                       0x87E1
+#define GL_CURRENT_VERTEX_EXT                                   0x87E2
+#define GL_MVP_MATRIX_EXT                                       0x87E3
+#define GL_VARIANT_VALUE_EXT                                    0x87E4
+#define GL_VARIANT_DATATYPE_EXT                                 0x87E5
+#define GL_VARIANT_ARRAY_STRIDE_EXT                             0x87E6
+#define GL_VARIANT_ARRAY_TYPE_EXT                               0x87E7
+#define GL_VARIANT_ARRAY_EXT                                    0x87E8
+#define GL_VARIANT_ARRAY_POINTER_EXT                            0x87E9
+#define GL_INVARIANT_VALUE_EXT                                  0x87EA
+#define GL_INVARIANT_DATATYPE_EXT                               0x87EB
+#define GL_LOCAL_CONSTANT_VALUE_EXT                             0x87EC
+#define GL_LOCAL_CONSTANT_DATATYPE_EXT                          0x87ED
+
+typedef void (APIENTRY * glBeginVertexShaderEXTPROC) ();
+typedef void (APIENTRY * glEndVertexShaderEXTPROC) ();
+typedef void (APIENTRY * glBindVertexShaderEXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * glGenVertexShadersEXTPROC) (GLuint range);
+typedef void (APIENTRY * glDeleteVertexShaderEXTPROC) (GLuint id);
+typedef void (APIENTRY * glShaderOp1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
+typedef void (APIENTRY * glShaderOp2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+typedef void (APIENTRY * glShaderOp3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+typedef void (APIENTRY * glSwizzleEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * glWriteMaskEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * glInsertComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef void (APIENTRY * glExtractComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef GLuint (APIENTRY * glGenSymbolsEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components);
+typedef void (APIENTRY * glSetInvariantEXTPROC) (GLuint id, GLenum type, GLvoid *addr);
+typedef void (APIENTRY * glSetLocalConstantEXTPROC) (GLuint id, GLenum type, GLvoid *addr);
+typedef void (APIENTRY * glVariantbvEXTPROC) (GLuint id, GLbyte *addr);
+typedef void (APIENTRY * glVariantsvEXTPROC) (GLuint id, GLshort *addr);
+typedef void (APIENTRY * glVariantivEXTPROC) (GLuint id, GLint *addr);
+typedef void (APIENTRY * glVariantfvEXTPROC) (GLuint id, GLfloat *addr);
+typedef void (APIENTRY * glVariantdvEXTPROC) (GLuint id, GLdouble *addr);
+typedef void (APIENTRY * glVariantubvEXTPROC) (GLuint id, GLubyte *addr);
+typedef void (APIENTRY * glVariantusvEXTPROC) (GLuint id, GLushort *addr);
+typedef void (APIENTRY * glVariantuivEXTPROC) (GLuint id, GLuint *addr);
+typedef void (APIENTRY * glVariantPointerEXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid *addr);
+typedef void (APIENTRY * glEnableVariantClientStateEXTPROC) (GLuint id);
+typedef void (APIENTRY * glDisableVariantClientStateEXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * glBindLightParameterEXTPROC) (GLenum light, GLenum value);
+typedef GLuint (APIENTRY * glBindMaterialParameterEXTPROC) (GLenum face, GLenum value);
+typedef GLuint (APIENTRY * glBindTexGenParameterEXTPROC) (GLenum unit, GLenum coord, GLenum value);
+typedef GLuint (APIENTRY * glBindTextureUnitParameterEXTPROC) (GLenum unit, GLenum value);
+typedef GLuint (APIENTRY * glBindParameterEXTPROC) (GLenum value);
+typedef GLboolean (APIENTRY * glIsVariantEnabledEXTPROC) (GLuint id, GLenum cap);
+typedef void (APIENTRY * glGetVariantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetVariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetVariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * glGetVariantPointervEXTPROC) (GLuint id, GLenum value, GLvoid **data);
+typedef void (APIENTRY * glGetInvariantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetInvariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetInvariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * glGetLocalConstantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetLocalConstantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetLocalConstantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+
+extern glBeginVertexShaderEXTPROC glBeginVertexShaderEXT;
+extern glEndVertexShaderEXTPROC glEndVertexShaderEXT;
+extern glBindVertexShaderEXTPROC glBindVertexShaderEXT;
+extern glGenVertexShadersEXTPROC glGenVertexShadersEXT;
+extern glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT;
+extern glShaderOp1EXTPROC glShaderOp1EXT;
+extern glShaderOp2EXTPROC glShaderOp2EXT;
+extern glShaderOp3EXTPROC glShaderOp3EXT;
+extern glSwizzleEXTPROC glSwizzleEXT;
+extern glWriteMaskEXTPROC glWriteMaskEXT;
+extern glInsertComponentEXTPROC glInsertComponentEXT;
+extern glExtractComponentEXTPROC glExtractComponentEXT;
+extern glGenSymbolsEXTPROC glGenSymbolsEXT;
+extern glSetInvariantEXTPROC glSetInvariantEXT;
+extern glSetLocalConstantEXTPROC glSetLocalConstantEXT;
+extern glVariantbvEXTPROC glVariantbvEXT;
+extern glVariantsvEXTPROC glVariantsvEXT;
+extern glVariantivEXTPROC glVariantivEXT;
+extern glVariantfvEXTPROC glVariantfvEXT;
+extern glVariantdvEXTPROC glVariantdvEXT;
+extern glVariantubvEXTPROC glVariantubvEXT;
+extern glVariantusvEXTPROC glVariantusvEXT;
+extern glVariantuivEXTPROC glVariantuivEXT;
+extern glVariantPointerEXTPROC glVariantPointerEXT;
+extern glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT;
+extern glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT;
+extern glBindLightParameterEXTPROC glBindLightParameterEXT;
+extern glBindMaterialParameterEXTPROC glBindMaterialParameterEXT;
+extern glBindTexGenParameterEXTPROC glBindTexGenParameterEXT;
+extern glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT;
+extern glBindParameterEXTPROC glBindParameterEXT;
+extern glIsVariantEnabledEXTPROC glIsVariantEnabledEXT;
+extern glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT;
+extern glGetVariantIntegervEXTPROC glGetVariantIntegervEXT;
+extern glGetVariantFloatvEXTPROC glGetVariantFloatvEXT;
+extern glGetVariantPointervEXTPROC glGetVariantPointervEXT;
+extern glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT;
+extern glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT;
+extern glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT;
+extern glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT;
+extern glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT;
+extern glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT;
+
+#endif /* GL_EXT_vertex_shader */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_ENVMAP_BUMPMAP-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_envmap_bumpmap
+#define GL_ATI_envmap_bumpmap 1
+
+#define GL_BUMP_ROT_MATRIX_ATI                                  0x8775
+#define GL_BUMP_ROT_MATRIX_SIZE_ATI                             0x8776
+#define GL_BUMP_NUM_TEX_UNITS_ATI                               0x8777
+#define GL_BUMP_TEX_UNITS_ATI                                   0x8778
+#define GL_DUDV_ATI                                             0x8779
+#define GL_DU8DV8_ATI                                           0x877A
+#define GL_BUMP_ENVMAP_ATI                                      0x877B
+#define GL_BUMP_TARGET_ATI                                      0x877C
+
+typedef void (APIENTRY * glTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRY * glTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
+typedef void (APIENTRY * glGetTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRY * glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
+
+extern glTexBumpParameterivATIPROC glTexBumpParameterivATI;
+extern glTexBumpParameterfvATIPROC glTexBumpParameterfvATI;
+extern glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI;
+extern glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI;
+
+#endif /* GL_ATI_envmap_bumpmap */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_FRAGMENT_SHADER------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_fragment_shader
+#define GL_ATI_fragment_shader 1
+
+#define GL_FRAGMENT_SHADER_ATI                                  0x8920
+#define GL_REG_0_ATI                                            0x8921
+#define GL_REG_1_ATI                                            0x8922
+#define GL_REG_2_ATI                                            0x8923
+#define GL_REG_3_ATI                                            0x8924
+#define GL_REG_4_ATI                                            0x8925
+#define GL_REG_5_ATI                                            0x8926
+#define GL_REG_6_ATI                                            0x8927
+#define GL_REG_7_ATI                                            0x8928
+#define GL_REG_8_ATI                                            0x8929
+#define GL_REG_9_ATI                                            0x892A
+#define GL_REG_10_ATI                                           0x892B
+#define GL_REG_11_ATI                                           0x892C
+#define GL_REG_12_ATI                                           0x892D
+#define GL_REG_13_ATI                                           0x892E
+#define GL_REG_14_ATI                                           0x892F
+#define GL_REG_15_ATI                                           0x8930
+#define GL_REG_16_ATI                                           0x8931
+#define GL_REG_17_ATI                                           0x8932
+#define GL_REG_18_ATI                                           0x8933
+#define GL_REG_19_ATI                                           0x8934
+#define GL_REG_20_ATI                                           0x8935
+#define GL_REG_21_ATI                                           0x8936
+#define GL_REG_22_ATI                                           0x8937
+#define GL_REG_23_ATI                                           0x8938
+#define GL_REG_24_ATI                                           0x8939
+#define GL_REG_25_ATI                                           0x893A
+#define GL_REG_26_ATI                                           0x893B
+#define GL_REG_27_ATI                                           0x893C
+#define GL_REG_28_ATI                                           0x893D
+#define GL_REG_29_ATI                                           0x893E
+#define GL_REG_30_ATI                                           0x893F
+#define GL_REG_31_ATI                                           0x8940
+#define GL_CON_0_ATI                                            0x8941
+#define GL_CON_1_ATI                                            0x8942
+#define GL_CON_2_ATI                                            0x8943
+#define GL_CON_3_ATI                                            0x8944
+#define GL_CON_4_ATI                                            0x8945
+#define GL_CON_5_ATI                                            0x8946
+#define GL_CON_6_ATI                                            0x8947
+#define GL_CON_7_ATI                                            0x8948
+#define GL_CON_8_ATI                                            0x8949
+#define GL_CON_9_ATI                                            0x894A
+#define GL_CON_10_ATI                                           0x894B
+#define GL_CON_11_ATI                                           0x894C
+#define GL_CON_12_ATI                                           0x894D
+#define GL_CON_13_ATI                                           0x894E
+#define GL_CON_14_ATI                                           0x894F
+#define GL_CON_15_ATI                                           0x8950
+#define GL_CON_16_ATI                                           0x8951
+#define GL_CON_17_ATI                                           0x8952
+#define GL_CON_18_ATI                                           0x8953
+#define GL_CON_19_ATI                                           0x8954
+#define GL_CON_20_ATI                                           0x8955
+#define GL_CON_21_ATI                                           0x8956
+#define GL_CON_22_ATI                                           0x8957
+#define GL_CON_23_ATI                                           0x8958
+#define GL_CON_24_ATI                                           0x8959
+#define GL_CON_25_ATI                                           0x895A
+#define GL_CON_26_ATI                                           0x895B
+#define GL_CON_27_ATI                                           0x895C
+#define GL_CON_28_ATI                                           0x895D
+#define GL_CON_29_ATI                                           0x895E
+#define GL_CON_30_ATI                                           0x895F
+#define GL_CON_31_ATI                                           0x8960
+#define GL_MOV_ATI                                              0x8961
+#define GL_ADD_ATI                                              0x8963
+#define GL_MUL_ATI                                              0x8964
+#define GL_SUB_ATI                                              0x8965
+#define GL_DOT3_ATI                                             0x8966
+#define GL_DOT4_ATI                                             0x8967
+#define GL_MAD_ATI                                              0x8968
+#define GL_LERP_ATI                                             0x8969
+#define GL_CND_ATI                                              0x896A
+#define GL_CND0_ATI                                             0x896B
+#define GL_DOT2_ADD_ATI                                         0x896C
+#define GL_SECONDARY_INTERPOLATOR_ATI                           0x896D
+#define GL_NUM_FRAGMENT_REGISTERS_ATI                           0x896E
+#define GL_NUM_FRAGMENT_CONSTANTS_ATI                           0x896F
+#define GL_NUM_PASSES_ATI                                       0x8970
+#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI                        0x8971
+#define GL_NUM_INSTRUCTIONS_TOTAL_ATI                           0x8972
+#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI                0x8973
+#define GL_NUM_LOOPBACK_COMPONENTS_ATI                          0x8974
+#define GL_COLOR_ALPHA_PAIRING_ATI                              0x8975
+#define GL_SWIZZLE_STR_ATI                                      0x8976
+#define GL_SWIZZLE_STQ_ATI                                      0x8977
+#define GL_SWIZZLE_STR_DR_ATI                                   0x8978
+#define GL_SWIZZLE_STQ_DQ_ATI                                   0x8979
+#define GL_SWIZZLE_STRQ_ATI                                     0x897A
+#define GL_SWIZZLE_STRQ_DQ_ATI                                  0x897B
+#define GL_RED_BIT_ATI                                          0x00000001
+#define GL_GREEN_BIT_ATI                                        0x00000002
+#define GL_BLUE_BIT_ATI                                         0x00000004
+#define GL_2X_BIT_ATI                                           0x00000001
+#define GL_4X_BIT_ATI                                           0x00000002
+#define GL_8X_BIT_ATI                                           0x00000004
+#define GL_HALF_BIT_ATI                                         0x00000008
+#define GL_QUARTER_BIT_ATI                                      0x00000010
+#define GL_EIGHTH_BIT_ATI                                       0x00000020
+#define GL_SATURATE_BIT_ATI                                     0x00000040
+#define GL_COMP_BIT_ATI                                         0x00000002
+#define GL_NEGATE_BIT_ATI                                       0x00000004
+#define GL_BIAS_BIT_ATI                                         0x00000008
+
+typedef GLuint (APIENTRY * glGenFragmentShadersATIPROC) (GLuint range);
+typedef void (APIENTRY * glBindFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY * glDeleteFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY * glBeginFragmentShaderATIPROC) (GLvoid);
+typedef void (APIENTRY * glEndFragmentShaderATIPROC) (GLvoid);
+typedef void (APIENTRY * glPassTexCoordATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
+typedef void (APIENTRY * glSampleMapATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
+typedef void (APIENTRY * glColorFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * glColorFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * glColorFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * glAlphaFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * glAlphaFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * glAlphaFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * glSetFragmentShaderConstantATIPROC) (GLuint dst, const GLfloat *value);
+
+extern glGenFragmentShadersATIPROC glGenFragmentShadersATI;
+extern glBindFragmentShaderATIPROC glBindFragmentShaderATI;
+extern glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI;
+extern glBeginFragmentShaderATIPROC glBeginFragmentShaderATI;
+extern glEndFragmentShaderATIPROC glEndFragmentShaderATI;
+extern glPassTexCoordATIPROC glPassTexCoordATI;
+extern glSampleMapATIPROC glSampleMapATI;
+extern glColorFragmentOp1ATIPROC glColorFragmentOp1ATI;
+extern glColorFragmentOp2ATIPROC glColorFragmentOp2ATI;
+extern glColorFragmentOp3ATIPROC glColorFragmentOp3ATI;
+extern glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI;
+extern glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI;
+extern glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI;
+extern glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI;
+
+#endif /* GL_ATI_fragment_shader */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_TEXTURE_MIRROR_ONCE--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_texture_mirror_once
+#define GL_ATI_texture_mirror_once 1
+
+#define GL_MIRROR_CLAMP_ATI                                     0x8742
+#define GL_MIRROR_CLAMP_TO_EDGE_ATI                             0x8743
+
+#endif
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_ELEMENT_ARRAY--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_element_array
+#define GL_ATI_element_array 1
+
+#define GL_ELEMENT_ARRAY_ATI                                    0x8768
+#define GL_ELEMENT_ARRAY_TYPE_ATI                               0x8769
+#define GL_ELEMENT_ARRAY_POINTER_ATI                            0x876A
+
+typedef void (APIENTRY * glElementPointerATIPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRY * glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
+typedef void (APIENTRY * glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
+
+extern glElementPointerATIPROC glElementPointerATI;
+extern glDrawElementArrayATIPROC glDrawElementArrayATI;
+extern glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI;
+
+#endif /* GL_ATI_element_array */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_VERTEX_STREAMS-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_vertex_streams 
+#define GL_ATI_vertex_streams 1
+
+#define GL_MAX_VERTEX_STREAMS_ATI                               0x876B  
+#define GL_VERTEX_SOURCE_ATI                                    0x876C
+#define GL_VERTEX_STREAM0_ATI                                   0x876D
+#define GL_VERTEX_STREAM1_ATI                                   0x876E
+#define GL_VERTEX_STREAM2_ATI                                   0x876F
+#define GL_VERTEX_STREAM3_ATI                                   0x8770
+#define GL_VERTEX_STREAM4_ATI                                   0x8771
+#define GL_VERTEX_STREAM5_ATI                                   0x8772
+#define GL_VERTEX_STREAM6_ATI                                   0x8773
+#define GL_VERTEX_STREAM7_ATI                                   0x8774
+
+typedef void (APIENTRY * glClientActiveVertexStreamATIPROC) (GLenum stream);
+typedef void (APIENTRY * glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glVertexStream2sATIPROC) (GLenum stream, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexStream2svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream2iATIPROC) (GLenum stream, GLint x, GLint y);
+typedef void (APIENTRY * glVertexStream2ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream2fATIPROC) (GLenum stream, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexStream2fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream2dATIPROC) (GLenum stream, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexStream2dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glVertexStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexStream3svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glVertexStream3ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexStream3fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexStream3dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glVertexStream4sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexStream4svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream4iATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY * glVertexStream4ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream4fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexStream4fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream4dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexStream4dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z);
+typedef void (APIENTRY * glNormalStream3bvATIPROC) (GLenum stream, const GLbyte *v);
+typedef void (APIENTRY * glNormalStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glNormalStream3svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glNormalStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glNormalStream3ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glNormalStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glNormalStream3fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glNormalStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glNormalStream3dvATIPROC) (GLenum stream, const GLdouble *v);
+
+
+extern glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI;
+extern glVertexBlendEnviATIPROC glVertexBlendEnviATI;
+extern glVertexBlendEnvfATIPROC glVertexBlendEnvfATI;
+extern glVertexStream2sATIPROC glVertexStream2sATI;
+extern glVertexStream2svATIPROC glVertexStream2svATI;
+extern glVertexStream2iATIPROC glVertexStream2iATI;
+extern glVertexStream2ivATIPROC glVertexStream2ivATI;
+extern glVertexStream2fATIPROC glVertexStream2fATI;
+extern glVertexStream2fvATIPROC glVertexStream2fvATI;
+extern glVertexStream2dATIPROC glVertexStream2dATI;
+extern glVertexStream2dvATIPROC glVertexStream2dvATI;
+extern glVertexStream3sATIPROC glVertexStream3sATI;
+extern glVertexStream3svATIPROC glVertexStream3svATI;
+extern glVertexStream3iATIPROC glVertexStream3iATI;
+extern glVertexStream3ivATIPROC glVertexStream3ivATI;
+extern glVertexStream3fATIPROC glVertexStream3fATI;
+extern glVertexStream3fvATIPROC glVertexStream3fvATI;
+extern glVertexStream3dATIPROC glVertexStream3dATI;
+extern glVertexStream3dvATIPROC glVertexStream3dvATI;
+extern glVertexStream4sATIPROC glVertexStream4sATI;
+extern glVertexStream4svATIPROC glVertexStream4svATI;
+extern glVertexStream4iATIPROC glVertexStream4iATI;
+extern glVertexStream4ivATIPROC glVertexStream4ivATI;
+extern glVertexStream4fATIPROC glVertexStream4fATI;
+extern glVertexStream4fvATIPROC glVertexStream4fvATI;
+extern glVertexStream4dATIPROC glVertexStream4dATI;
+extern glVertexStream4dvATIPROC glVertexStream4dvATI;
+extern glNormalStream3bATIPROC glNormalStream3bATI;
+extern glNormalStream3bvATIPROC glNormalStream3bvATI;
+extern glNormalStream3sATIPROC glNormalStream3sATI;
+extern glNormalStream3svATIPROC glNormalStream3svATI;
+extern glNormalStream3iATIPROC glNormalStream3iATI;
+extern glNormalStream3ivATIPROC glNormalStream3ivATI;
+extern glNormalStream3fATIPROC glNormalStream3fATI;
+extern glNormalStream3fvATIPROC glNormalStream3fvATI;
+extern glNormalStream3dATIPROC glNormalStream3dATI;
+extern glNormalStream3dvATIPROC glNormalStream3dvATI;
+
+#endif /* GL_ATI_vertex_streams */
+
+/*-------------------------------------------------------------------*/
+/*------------ATI_VERTEX_ARRAY_OBJECT--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_vertex_array_object
+#define GL_ATI_vertex_array_object 1
+
+#define GL_STATIC_ATI                                           0x8760
+#define GL_DYNAMIC_ATI                                          0x8761
+#define GL_PRESERVE_ATI                                         0x8762
+#define GL_DISCARD_ATI                                          0x8763
+#define GL_OBJECT_BUFFER_SIZE_ATI                               0x8764
+#define GL_OBJECT_BUFFER_USAGE_ATI                              0x8765
+#define GL_ARRAY_OBJECT_BUFFER_ATI                              0x8766
+#define GL_ARRAY_OBJECT_OFFSET_ATI                              0x8767
+
+typedef GLuint (APIENTRY * glNewObjectBufferATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage);
+typedef GLboolean (APIENTRY * glIsObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY * glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
+typedef void (APIENTRY * glGetObjectBufferfvATIPROC) (GLuint buffer, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetObjectBufferivATIPROC) (GLuint buffer, GLenum pname, GLint *params);
+typedef void (APIENTRY * glFreeObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY * glArrayObjectATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * glGetArrayObjectfvATIPROC) (GLenum array, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetArrayObjectivATIPROC) (GLenum array, GLenum pname, GLint *params);
+typedef void (APIENTRY * glVariantArrayObjectATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * glGetVariantArrayObjectfvATIPROC) (GLuint id, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVariantArrayObjectivATIPROC) (GLuint id, GLenum pname, GLint *params);
+
+extern glNewObjectBufferATIPROC glNewObjectBufferATI;
+extern glIsObjectBufferATIPROC glIsObjectBufferATI;
+extern glUpdateObjectBufferATIPROC glUpdateObjectBufferATI;
+extern glGetObjectBufferfvATIPROC glGetObjectBufferfvATI;
+extern glGetObjectBufferivATIPROC glGetObjectBufferivATI;
+extern glFreeObjectBufferATIPROC glFreeObjectBufferATI;
+extern glArrayObjectATIPROC glArrayObjectATI;
+extern glGetArrayObjectfvATIPROC glGetArrayObjectfvATI;
+extern glGetArrayObjectivATIPROC glGetArrayObjectivATI;
+extern glVariantArrayObjectATIPROC glVariantArrayObjectATI;
+extern glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI;
+extern glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI;
+
+#endif /* GL_ATI_vertex_array_object */
+
+/*-------------------------------------------------------------------*/
+/*------------HP_OCCLUSION_TEST--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+
+#define GL_OCCLUSION_TEST_HP                                    0x8165;
+#define GL_OCCLUSION_TEST_RESULT_HP                             0x8166;
+
+#endif /* GL_HP_occlusion_test */
+
+/*-------------------------------------------------------------------*/
+/*------------ATIX_POINT_SPRITES-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATIX_point_sprites
+#define GL_ATIX_point_sprites 1
+
+#define GL_TEXTURE_POINT_MODE_ATIX                               0x60b0
+#define	GL_TEXTURE_POINT_ONE_COORD_ATIX                          0x60b1
+#define	GL_TEXTURE_POINT_SPRITE_ATIX                             0x60b2
+#define GL_POINT_SPRITE_CULL_MODE_ATIX                           0x60b3
+#define GL_POINT_SPRITE_CULL_CENTER_ATIX                         0x60b4
+#define GL_POINT_SPRITE_CULL_CLIP_ATIX                           0x60b5
+
+#endif /* GL_ATIX_point_sprites */
+
+/*-------------------------------------------------------------------*/
+/*------------ATIX_TEXTURE_ENV_ROUTE---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATIX_texture_env_route
+#define GL_ATIX_texture_env_route 1
+
+#define GL_SECONDARY_COLOR_ATIX                                  0x8747
+#define GL_TEXTURE_OUTPUT_RGB_ATIX                               0x8748
+#define GL_TEXTURE_OUTPUT_ALPHA_ATIX                             0x8749
+
+#endif /* GL_ATIX_texture_env_route */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_DEPTH_CLAMP-----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_depth_clamp
+#define GL_NV_depth_clamp 1
+
+#define GL_DEPTH_CLAMP_NV                                       0x864F
+
+#endif /* GL_NV_depth_clamp */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_OCCLUSION_QUERY-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_occlusion_query
+#define GL_NV_occlusion_query 1
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP                                    0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP                             0x8166
+#endif /* GL_HP_occlusion_test */
+#define GL_PIXEL_COUNTER_BITS_NV                                0x8864
+#define GL_CURRENT_OCCLUSION_QUERY_ID_NV                        0x8865
+#define GL_PIXEL_COUNT_NV                                       0x8866
+#define GL_PIXEL_COUNT_AVAILABLE_NV                             0x8867
+
+typedef void (APIENTRY * glGenOcclusionQueriesNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRY * glDeleteOcclusionQueriesNVPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRY * glIsOcclusionQueryNVPROC) (GLuint id);
+typedef void (APIENTRY * glBeginOcclusionQueryNVPROC) (GLuint id);
+typedef void (APIENTRY * glEndOcclusionQueryNVPROC) (void);
+typedef void (APIENTRY * glGetOcclusionQueryivNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetOcclusionQueryuivNVPROC) (GLuint id, GLenum pname, GLuint *params);
+
+extern glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV;
+extern glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV;
+extern glIsOcclusionQueryNVPROC glIsOcclusionQueryNV;
+extern glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV;
+extern glEndOcclusionQueryNVPROC glEndOcclusionQueryNV;
+extern glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV;
+extern glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV;
+
+#endif /* GL_NV_occlusion_query */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_POINT_SPRITE----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_point_sprite
+#define GL_NV_point_sprite 1
+
+#define GL_POINT_SPRITE_NV                                      0x8861
+#define GL_COORD_REPLACE_NV                                     0x8862
+#define GL_POINT_SPRITE_R_MODE_NV                               0x8863
+
+typedef void (APIENTRY * glPointParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glPointParameterivNVPROC) (GLenum pname, const GLint *params);
+
+extern glPointParameteriNVPROC glPointParameteriNV;
+extern glPointParameterivNVPROC glPointParameterivNV;
+
+#endif /* GL_NV_point_sprite */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_TEXTURE_SHADER3-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_texture_shader3
+#define GL_NV_texture_shader3 1
+
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV                      0x8850
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV                0x8851
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV               0x8852
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV         0x8853
+#define GL_OFFSET_HILO_TEXTURE_2D_NV                            0x8854
+#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV                     0x8855
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV                 0x8856
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV          0x8857
+#define GL_DEPENDENT_HILO_TEXTURE_2D_NV                         0x8858
+#define GL_DEPENDENT_RGB_TEXTURE_3D_NV                          0x8859
+#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV                    0x885A
+#define GL_DOT_PRODUCT_PASS_THROUGH_NV                          0x885B
+#define GL_DOT_PRODUCT_TEXTURE_1D_NV                            0x885C
+#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV                  0x885D
+#define GL_HILO8_NV                                             0x885E
+#define GL_SIGNED_HILO8_NV                                      0x885F
+#define GL_FORCE_BLUE_TO_ONE_NV                                 0x8860
+
+#endif /* GL_NV_texture_shader3 */
+
+/*-------------------------------------------------------------------*/
+/*------------NV_VERTEX_PROGRAM1_1-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_vertex_program1_1
+#define GL_NV_vertex_program1_1
+
+#endif /* GL_NV_vertex_program1_1 */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_TEXTURE_MIRRORED_REPEAT----------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_texture_mirrored_repeat
+#define GL_ARB_texture_mirrored_repeat 1
+
+#define GL_GL_MIRRORED_REPEAT_ARB                               0x8370
+
+#endif /* GL_ARB_texture_mirrored_repeat */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_SHADOW---------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_shadow
+#define GL_ARB_shadow 1
+
+#define GL_TEXTURE_COMPARE_MODE_ARB                             0x884C
+#define GL_TEXTURE_COMPARE_FUNC_ARB                             0x884D
+#define GL_COMPARE_R_TO_TEXTURE_ARB                             0x884E
+
+#endif /* GL_ARB_shadow */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_SHADOW_AMBIENT-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_shadow_ambient
+#define GL_ARB_shadow_ambient 1
+
+#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB                       0x80BF 
+
+#endif /* GL_ARB_shadow_ambient */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_DEPTH_TEXTURE--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_depth_texture
+#define GL_ARB_depth_texture 1
+
+#define GL_DEPTH_COMPONENT16_ARB                                0x81A5
+#define GL_DEPTH_COMPONENT24_ARB                                0x81A6
+#define GL_DEPTH_COMPONENT32_ARB                                0x81A7
+#define GL_TEXTURE_DEPTH_SIZE_ARB                               0x884A
+#define GL_DEPTH_TEXTURE_MODE_ARB                               0x884B
+
+#endif /* GL_ARB_depth_texture */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_WINDOW_POS-----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_window_pos
+#define GL_ARB_window_pos 1
+
+typedef void (APIENTRY * glWindowPos2dARBPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * glWindowPos2fARBPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * glWindowPos2iARBPROC) (GLint x, GLint y);
+typedef void (APIENTRY * glWindowPos2sARBPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * glWindowPos2dvARBPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos2fvARBPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos2ivARBPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos2svARBPROC) (const GLshort *p);
+typedef void (APIENTRY * glWindowPos3dARBPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glWindowPos3fARBPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glWindowPos3iARBPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glWindowPos3sARBPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glWindowPos3dvARBPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos3fvARBPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos3ivARBPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos3svARBPROC) (const GLshort *p);
+
+extern glWindowPos2dARBPROC glWindowPos2dARB;
+extern glWindowPos2fARBPROC glWindowPos2fARB;
+extern glWindowPos2iARBPROC glWindowPos2iARB;
+extern glWindowPos2sARBPROC glWindowPos2sARB;
+extern glWindowPos2dvARBPROC glWindowPos2dvARB;
+extern glWindowPos2fvARBPROC glWindowPos2fvARB;
+extern glWindowPos2ivARBPROC glWindowPos2ivARB;
+extern glWindowPos2svARBPROC glWindowPos2svARB;
+extern glWindowPos3dARBPROC glWindowPos3dARB;
+extern glWindowPos3fARBPROC glWindowPos3fARB;
+extern glWindowPos3iARBPROC glWindowPos3iARB;
+extern glWindowPos3sARBPROC glWindowPos3sARB;
+extern glWindowPos3dvARBPROC glWindowPos3dvARB;
+extern glWindowPos3fvARBPROC glWindowPos3fvARB;
+extern glWindowPos3ivARBPROC glWindowPos3ivARB;
+extern glWindowPos3svARBPROC glWindowPos3svARB;
+
+#endif /* GL_ARB_window_pos */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_SHADOW_FUNCS---------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_shadow_funcs
+#define GL_EXT_shadow_funcs 1
+
+#endif /* GL_EXT_shadow_funcs */
+
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_draw_range_elements--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+
+typedef void (APIENTRY * glDrawRangeElementsEXTPROC) ( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+
+extern glDrawRangeElementsEXTPROC glDrawRangeElementsEXT;
+
+#define GL_MAX_ELEMENTS_VERTICES_EXT                            0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT                             0x80E9
+
+#endif
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_texture_compression_s3tc---------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_EXT_texture_compression_s3tc 1
+
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                         0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                        0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                        0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                        0x83F3
+
+#endif /* GL_EXT_texture_compression_s3tc */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_stencil_two_side-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_stencil_two_side
+#define GL_EXT_stencil_two_side 1
+
+typedef void (APIENTRY * glActiveStencilFaceEXTPROC) (GLenum face);
+
+extern glActiveStencilFaceEXTPROC glActiveStencilFaceEXT;
+
+#define GL_STENCIL_TEST_TWO_SIDE_EXT                            0x8910
+#define GL_ACTIVE_STENCIL_FACE_EXT                              0x8911
+
+#endif /* GL_EXT_stencil_two_side */
+
+/*-------------------------------------------------------------------*/
+/*------------ARB_vertex_program-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_vertex_program
+#define GL_ARB_vertex_program 1
+
+typedef void (APIENTRY * glVertexAttrib1sARBPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * glVertexAttrib1fARBPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * glVertexAttrib1dARBPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * glVertexAttrib2sARBPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexAttrib2fARBPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexAttrib2dARBPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexAttrib3sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexAttrib3fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexAttrib3dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexAttrib4sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexAttrib4fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexAttrib4dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * glVertexAttrib1svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib1fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib1dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib2svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib2fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib2dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib3svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib3fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib3dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4bvARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * glVertexAttrib4svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4ivARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * glVertexAttrib4ubvARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttrib4usvARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * glVertexAttrib4uivARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * glVertexAttrib4fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib4dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4NbvARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * glVertexAttrib4NsvARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4NivARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * glVertexAttrib4NubvARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttrib4NusvARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * glVertexAttrib4NuivARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glEnableVertexAttribArrayARBPROC) (GLuint index);
+typedef void (APIENTRY * glDisableVertexAttribArrayARBPROC) (GLuint index);
+typedef void (APIENTRY * glProgramStringARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); 
+typedef void (APIENTRY * glBindProgramARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRY * glDeleteProgramsARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * glGenProgramsARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * glProgramEnvParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramEnvParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramEnvParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramEnvParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glProgramLocalParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramLocalParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glGetProgramEnvParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramEnvParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * glGetProgramLocalParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * glGetProgramivARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetProgramStringARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef void (APIENTRY * glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid **pointer);
+typedef GLboolean (APIENTRY * glIsProgramARBPROC) (GLuint program);
+
+extern glVertexAttrib1sARBPROC glVertexAttrib1sARB;
+extern glVertexAttrib1fARBPROC glVertexAttrib1fARB;
+extern glVertexAttrib1dARBPROC glVertexAttrib1dARB;
+extern glVertexAttrib2sARBPROC glVertexAttrib2sARB;
+extern glVertexAttrib2fARBPROC glVertexAttrib2fARB;
+extern glVertexAttrib2dARBPROC glVertexAttrib2dARB;
+extern glVertexAttrib3sARBPROC glVertexAttrib3sARB;
+extern glVertexAttrib3fARBPROC glVertexAttrib3fARB;
+extern glVertexAttrib3dARBPROC glVertexAttrib3dARB;
+extern glVertexAttrib4sARBPROC glVertexAttrib4sARB;
+extern glVertexAttrib4fARBPROC glVertexAttrib4fARB;
+extern glVertexAttrib4dARBPROC glVertexAttrib4dARB;
+extern glVertexAttrib4NubARBPROC glVertexAttrib4NubARB;
+extern glVertexAttrib1svARBPROC glVertexAttrib1svARB;
+extern glVertexAttrib1fvARBPROC glVertexAttrib1fvARB;
+extern glVertexAttrib1dvARBPROC glVertexAttrib1dvARB;
+extern glVertexAttrib2svARBPROC glVertexAttrib2svARB;
+extern glVertexAttrib2fvARBPROC glVertexAttrib2fvARB;
+extern glVertexAttrib2dvARBPROC glVertexAttrib2dvARB;
+extern glVertexAttrib3svARBPROC glVertexAttrib3svARB;
+extern glVertexAttrib3fvARBPROC glVertexAttrib3fvARB;
+extern glVertexAttrib3dvARBPROC glVertexAttrib3dvARB;
+extern glVertexAttrib4bvARBPROC glVertexAttrib4bvARB;
+extern glVertexAttrib4svARBPROC glVertexAttrib4svARB;
+extern glVertexAttrib4ivARBPROC glVertexAttrib4ivARB;
+extern glVertexAttrib4ubvARBPROC glVertexAttrib4ubvARB;
+extern glVertexAttrib4usvARBPROC glVertexAttrib4usvARB;
+extern glVertexAttrib4uivARBPROC glVertexAttrib4uivARB;
+extern glVertexAttrib4fvARBPROC glVertexAttrib4fvARB;
+extern glVertexAttrib4dvARBPROC glVertexAttrib4dvARB;
+extern glVertexAttrib4NbvARBPROC glVertexAttrib4NbvARB;
+extern glVertexAttrib4NsvARBPROC glVertexAttrib4NsvARB;
+extern glVertexAttrib4NivARBPROC glVertexAttrib4NivARB;
+extern glVertexAttrib4NubvARBPROC glVertexAttrib4NubvARB;
+extern glVertexAttrib4NusvARBPROC glVertexAttrib4NusvARB;
+extern glVertexAttrib4NuivARBPROC glVertexAttrib4NuivARB;
+extern glVertexAttribPointerARBPROC glVertexAttribPointerARB;
+extern glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB;
+extern glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB;
+extern glProgramStringARBPROC glProgramStringARB;
+extern glBindProgramARBPROC glBindProgramARB;
+extern glDeleteProgramsARBPROC glDeleteProgramsARB;
+extern glGenProgramsARBPROC glGenProgramsARB;
+extern glProgramEnvParameter4dARBPROC glProgramEnvParameter4dARB;
+extern glProgramEnvParameter4dvARBPROC glProgramEnvParameter4dvARB;
+extern glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB;
+extern glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB;
+extern glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB;
+extern glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB;
+extern glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB;
+extern glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB;
+extern glGetProgramEnvParameterdvARBPROC glGetProgramEnvParameterdvARB;
+extern glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB;
+extern glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB;
+extern glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB;
+extern glGetProgramivARBPROC glGetProgramivARB;
+extern glGetProgramStringARBPROC glGetProgramStringARB;
+extern glGetVertexAttribdvARBPROC glGetVertexAttribdvARB;
+extern glGetVertexAttribfvARBPROC glGetVertexAttribfvARB;
+extern glGetVertexAttribivARBPROC glGetVertexAttribivARB;
+extern glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB;
+extern glIsProgramARBPROC glIsProgramARB;
+
+#define GL_VERTEX_PROGRAM_ARB                                   0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB                        0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB                          0x8643
+#define GL_COLOR_SUM_ARB                                        0x8458
+#define GL_PROGRAM_FORMAT_ASCII_ARB                             0x8875
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB                      0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB                         0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB                       0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB                         0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB                   0x886A
+#define GL_CURRENT_VERTEX_ATTRIB_ARB                            0x8626
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB                      0x8645
+#define GL_PROGRAM_LENGTH_ARB                                   0x8627
+#define GL_PROGRAM_FORMAT_ARB                                   0x8876
+#define GL_PROGRAM_BINDING_ARB                                  0x8677
+#define GL_PROGRAM_INSTRUCTIONS_ARB                             0x88A0
+#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB                         0x88A1
+#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB                      0x88A2
+#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB                  0x88A3
+#define GL_PROGRAM_TEMPORARIES_ARB                              0x88A4
+#define GL_MAX_PROGRAM_TEMPORARIES_ARB                          0x88A5
+#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB                       0x88A6
+#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB                   0x88A7
+#define GL_PROGRAM_PARAMETERS_ARB                               0x88A8
+#define GL_MAX_PROGRAM_PARAMETERS_ARB                           0x88A9
+#define GL_PROGRAM_NATIVE_PARAMETERS_ARB                        0x88AA
+#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB                    0x88AB
+#define GL_PROGRAM_ATTRIBS_ARB                                  0x88AC
+#define GL_MAX_PROGRAM_ATTRIBS_ARB                              0x88AD
+#define GL_PROGRAM_NATIVE_ATTRIBS_ARB                           0x88AE
+#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB                       0x88AF
+#define GL_PROGRAM_ADDRESS_REGISTERS_ARB                        0x88B0
+#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB                    0x88B1
+#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB                 0x88B2
+#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB             0x88B3
+#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB                     0x88B4
+#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB                       0x88B5
+#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB                      0x88B6
+#define GL_PROGRAM_STRING_ARB                                   0x8628
+#define GL_PROGRAM_ERROR_POSITION_ARB                           0x864B
+#define GL_CURRENT_MATRIX_ARB                                   0x8641
+#define GL_TRANSPOSE_CURRENT_MATRIX_ARB                         0x88B7
+#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB                       0x8640
+#define GL_MAX_VERTEX_ATTRIBS_ARB                               0x8869
+#define GL_MAX_PROGRAM_MATRICES_ARB                             0x862F
+#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB                   0x862E
+#define GL_PROGRAM_ERROR_STRING_ARB                             0x8874
+#define GL_MATRIX0_ARB                                          0x88C0
+#define GL_MATRIX1_ARB                                          0x88C1
+#define GL_MATRIX2_ARB                                          0x88C2
+#define GL_MATRIX3_ARB                                          0x88C3
+#define GL_MATRIX4_ARB                                          0x88C4
+#define GL_MATRIX5_ARB                                          0x88C5
+#define GL_MATRIX6_ARB                                          0x88C6
+#define GL_MATRIX7_ARB                                          0x88C7
+#define GL_MATRIX8_ARB                                          0x88C8
+#define GL_MATRIX9_ARB                                          0x88C9
+#define GL_MATRIX10_ARB                                         0x88CA
+#define GL_MATRIX11_ARB                                         0x88CB
+#define GL_MATRIX12_ARB                                         0x88CC
+#define GL_MATRIX13_ARB                                         0x88CD
+#define GL_MATRIX14_ARB                                         0x88CE
+#define GL_MATRIX15_ARB                                         0x88CF
+#define GL_MATRIX16_ARB                                         0x88D0
+#define GL_MATRIX17_ARB                                         0x88D1
+#define GL_MATRIX18_ARB                                         0x88D2
+#define GL_MATRIX19_ARB                                         0x88D3
+#define GL_MATRIX20_ARB                                         0x88D4
+#define GL_MATRIX21_ARB                                         0x88D5
+#define GL_MATRIX22_ARB                                         0x88D6
+#define GL_MATRIX23_ARB                                         0x88D7
+#define GL_MATRIX24_ARB                                         0x88D8
+#define GL_MATRIX25_ARB                                         0x88D9
+#define GL_MATRIX26_ARB                                         0x88DA
+#define GL_MATRIX27_ARB                                         0x88DB
+#define GL_MATRIX28_ARB                                         0x88DC
+#define GL_MATRIX29_ARB                                         0x88DD
+#define GL_MATRIX30_ARB                                         0x88DE
+#define GL_MATRIX31_ARB                                         0x88DF
+
+#endif /* GL_ARB_vertex_program */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_EXT_BGRA--------------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+
+#define GL_BGR_EXT                                              0x80E0
+#define GL_BGRA_EXT                                             0x80E1
+
+#endif /* GL_EXT_bgra */
+
+/*-------------------------------------------------------------------*/
+/*------------EXT_CULL_VERTEX----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+
+#define GL_CULL_VERTEX_EXT                                      0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT                         0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT                      0x81AC
+
+typedef void (APIENTRY * glCullParameterfvEXTPROC) (GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glCullParameterdvEXTPROC) (GLenum pname, GLdouble *params);
+
+extern glCullParameterfvEXTPROC glCullParameterfvEXT;
+extern glCullParameterdvEXTPROC glCullParameterdvEXT;
+ 
+
+#endif /* GL_EXT_cull_vertex */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_ATI_POINT_CULL_MODE---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_point_cull_mode
+#define GL_ATI_point_cull_mode 1
+
+#define GL_POINT_CULL_MODE_ATI                                  0x60b3
+#define GL_POINT_CULL_CENTER_ATI                                0x60b4
+#define GL_POINT_CLIP_ATI                                       0x60b5
+
+#endif /* GL_ATI_point_cull_mode */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_BLEND_FUNC_SEPARATE---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+
+#define GL_BLEND_DST_RGB_EXT                                    0x80C8
+#define GL_BLEND_SRC_RGB_EXT                                    0x80C9
+#define GL_BLEND_DST_ALPHA_EXT                                  0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT                                  0x80CB
+
+typedef void (APIENTRY * glBlendFuncSeparateEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+
+extern glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT;
+
+#endif /* GL_EXT_blend_func_separate */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_EXT_SEPARATE_SPECULAR_COLOR-------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT                        0x81F8
+#define GL_SINGLE_COLOR_EXT                                     0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT                          0x81FA
+
+#endif /* GL_EXT_separate_specular_color */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_ELEMENT_ARRAY------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_element_array
+#define GL_NV_element_array 1
+
+#define GL_ELEMENT_ARRAY_TYPE_NV                                0x8769
+#define GL_ELEMENT_ARRAY_POINTER_NV                             0x876A
+
+typedef void (APIENTRY * glElementPointerNVPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRY * glDrawElementArrayNVPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRY * glDrawRangeElementArrayNVPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
+typedef void (APIENTRY * glMultiDrawElementArrayNVPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawRangeElementArrayNVPROC) (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount);
+
+extern glElementPointerNVPROC glElementPointerNV;
+extern glDrawElementArrayNVPROC glDrawElementArrayNV;
+extern glDrawRangeElementArrayNVPROC glDrawRangeElementArrayNV;
+extern glMultiDrawElementArrayNVPROC glMultiDrawElementArrayNV;
+extern glMultiDrawRangeElementArrayNVPROC glMultiDrawRangeElementArrayNV;
+
+#endif /* GL_NV_element_array */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_FLOAT_BUFFER-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_float_buffer
+#define GL_NV_float_buffer 1
+
+#define GL_FLOAT_R_NV                                           0x8880
+#define GL_FLOAT_RG_NV                                          0x8881
+#define GL_FLOAT_RGB_NV                                         0x8882
+#define GL_FLOAT_RGBA_NV                                        0x8883
+#define GL_FLOAT_R32_NV                                         0x8885
+#define GL_FLOAT_R16_NV                                         0x8884
+#define GL_FLOAT_R32_NV                                         0x8885
+#define GL_FLOAT_RG16_NV                                        0x8886
+#define GL_FLOAT_RG32_NV                                        0x8887
+#define GL_FLOAT_RGB16_NV                                       0x8888
+#define GL_FLOAT_RGB32_NV                                       0x8889
+#define GL_FLOAT_RGBA16_NV                                      0x888A
+#define GL_FLOAT_RGBA32_NV                                      0x888B
+#define GL_TEXTURE_FLOAT_COMPONENTS_NV                          0x888C
+#define GL_FLOAT_CLEAR_COLOR_VALUE_NV                           0x888D
+#define GL_FLOAT_RGBA_MODE_NV                                   0x888E
+
+#ifdef _WIN32
+#define WGL_FLOAT_COMPONENTS_NV                                 0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV                0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV               0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV              0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV             0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV                                  0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV                                 0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV                                0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV                               0x20B8
+#endif /* _WIN32 */
+
+#endif /* GL_NV_float_buffer */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_FRAGMENT_PROGRAM---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_fragment_program
+#define GL_NV_fragment_program 1
+
+#define GL_FRAGMENT_PROGRAM_NV                                  0x8870
+#define GL_MAX_TEXTURE_COORDS_NV                                0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_NV                           0x8872
+#define GL_FRAGMENT_PROGRAM_BINDING_NV                          0x8873
+#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV             0x8868
+#define GL_PROGRAM_ERROR_STRING_NV                              0x8874
+
+typedef void (APIENTRY * glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramNamedParameter4dNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramNamedParameter4fvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[]);
+typedef void (APIENTRY * glProgramNamedParameter4dvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble v[]);
+typedef void (APIENTRY * glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
+typedef void (APIENTRY * glGetProgramNamedParameterdvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
+
+#ifndef GL_ARB_vertex_program
+typedef void (APIENTRY * glProgramLocalParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramLocalParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glGetProgramLocalParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+#endif /* GL_ARB_vertex_program */
+
+extern glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV;
+extern glProgramNamedParameter4dNVPROC glProgramNamedParameter4dNV;
+extern glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV;
+extern glProgramNamedParameter4dvNVPROC glProgramNamedParameter4dvNV;
+extern glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV;
+extern glGetProgramNamedParameterdvNVPROC glGetProgramNamedParameterdvNV;
+
+#ifndef GL_ARB_vertex_program
+extern glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB;
+extern glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB;
+extern glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB;
+extern glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB;
+extern glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB;
+extern glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB;
+#endif /* GL_ARB_vertex_program */
+
+#endif /* GL_NV_fragment_program */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_PRIMITIVE_RESTART--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_primitive_restart
+#define GL_NV_primitive_restart 1
+
+#define GL_PRIMITIVE_RESTART_NV                                 0x8558
+#define GL_PRIMITIVE_RESTART_INDEX_NV                           0x8559
+
+typedef void (APIENTRY * glPrimitiveRestartNVPROC) ();
+typedef void (APIENTRY * glPrimitiveRestartIndexNVPROC) (GLuint index);
+
+extern glPrimitiveRestartNVPROC glPrimitiveRestartNV;
+extern glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV;
+
+#endif /* GL_NV_primitive_restart */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_NV_VERTEX_PROGRAM2----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_NV_vertex_program2
+#define GL_NV_vertex_program2 1
+
+#endif /* GL_NV_vertex_program2 */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_ARB_FRAGMENT_PROGRAM--------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ARB_fragment_program
+#define GL_ARB_fragment_program
+
+#ifndef GL_ARB_vertex_program
+#error ARB_vertex_program not defined
+#endif
+
+/* no new entry points, all of ARB_vertex_program reused */
+
+#define GL_FRAGMENT_PROGRAM_ARB                                 0x8804
+#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB                         0x8805
+#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB                         0x8806
+#define GL_PROGRAM_TEX_INDIRECTIONS_ARB                         0x8807
+#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB                  0x8808
+#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB                  0x8809
+#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB                  0x880A
+#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB                     0x880B
+#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB                     0x880C
+#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB                     0x880D
+#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB              0x880E
+#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB              0x880F
+#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB              0x8810
+#define GL_MAX_TEXTURE_COORDS_ARB                               0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB                          0x8872
+
+#endif /* GL_ARB_fragment_program */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_ATI_TEXT_FRAGMENT_SHADER----------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_text_fragment_shader
+#define GL_ATI_text_fragment_shader 1
+
+#define GL_TEXT_FRAGMENT_SHADER_ATI                             0x8200
+
+#endif /* GL_ATI_text_fragment_shader */
+
+/*-------------------------------------------------------------------*/
+/*------------GL_EXT_textzre_env_combine-----------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+
+#define GL_COMBINE_EXT                                          0x8570
+#define GL_COMBINE_RGB_EXT                                      0x8571
+#define GL_COMBINE_ALPHA_EXT                                    0x8572
+#define GL_RGB_SCALE_EXT                                        0x8573
+#define GL_ADD_SIGNED_EXT                                       0x8574
+#define GL_INTERPOLATE_EXT                                      0x8575
+#define GL_CONSTANT_EXT                                         0x8576
+#define GL_PRIMARY_COLOR_EXT                                    0x8577
+#define GL_PREVIOUS_EXT                                         0x8578
+#define GL_SOURCE0_RGB_EXT                                      0x8580
+#define GL_SOURCE1_RGB_EXT                                      0x8581
+#define GL_SOURCE2_RGB_EXT                                      0x8582
+#define GL_SOURCE0_ALPHA_EXT                                    0x8588
+#define GL_SOURCE1_ALPHA_EXT                                    0x8589
+#define GL_SOURCE2_ALPHA_EXT                                    0x858A
+#define GL_OPERAND0_RGB_EXT                                     0x8590
+#define GL_OPERAND1_RGB_EXT                                     0x8591
+#define GL_OPERAND2_RGB_EXT                                     0x8592
+#define GL_OPERAND0_ALPHA_EXT                                   0x8598
+#define GL_OPERAND1_ALPHA_EXT                                   0x8599
+#define GL_OPERAND2_ALPHA_EXT                                   0x859A
+
+#endif /* GL_EXT_texture_env_combine */
+
+// added -ec
+/*-------------------------------------------------------------------*/
+/*------------GL_EXT_TEXTURE_RECTANGLE-------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_EXT_texture_rectangle
+#define GL_EXT_texture_rectangle 1
+
+#define GL_TEXTURE_RECTANGLE_EXT                                 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_EXT                         0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_EXT                           0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT                        0x84F8
+
+#endif /* GL_EXT_texture_rectangle */
+
+// added -ec
+/*-------------------------------------------------------------------*/
+/*------------GL_ATI_texture_float-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_texture_float
+#define GL_ATI_texture_float                1
+
+#define GL_RGBA_FLOAT32_ATI                 0x8814
+#define GL_RGB_FLOAT32_ATI                  0x8815
+#define GL_ALPHA_FLOAT32_ATI                0x8816
+#define GL_INTENSITY_FLOAT32_ATI            0x8817
+#define GL_LUMINANCE_FLOAT32_ATI            0x8818
+#define GL_LUMINANCE_ALPHA_FLOAT32_ATI      0x8819
+#define GL_RGBA_FLOAT16_ATI                 0x881A
+#define GL_RGB_FLOAT16_ATI                  0x881B
+#define GL_ALPHA_FLOAT16_ATI                0x881C
+#define GL_INTENSITY_FLOAT16_ATI            0x881D
+#define GL_LUMINANCE_FLOAT16_ATI            0x881E
+#define GL_LUMINANCE_ALPHA_FLOAT16_ATI      0x881F
+    
+#endif /* GL_ATI_texture_float */
+
+// added -ec
+/*-------------------------------------------------------------------*/
+/*------------GL_ATI_draw_buffers------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef GL_ATI_draw_buffers
+#define GL_ATI_draw_buffers     1
+//
+// requires GL_ARB_fragment_program
+//
+
+#define GL_MAX_DRAW_BUFFERS_ATI 0x8824
+#define GL_DRAW_BUFFER0_ATI     0x8825
+#define GL_DRAW_BUFFER1_ATI     0x8826
+#define GL_DRAW_BUFFER2_ATI     0x8827
+#define GL_DRAW_BUFFER3_ATI     0x8828
+#define GL_DRAW_BUFFER4_ATI     0x8829
+#define GL_DRAW_BUFFER5_ATI     0x882A
+#define GL_DRAW_BUFFER6_ATI     0x882B
+#define GL_DRAW_BUFFER7_ATI     0x882C
+#define GL_DRAW_BUFFER8_ATI     0x882D
+#define GL_DRAW_BUFFER9_ATI     0x882E
+#define GL_DRAW_BUFFER10_ATI    0x882F
+#define GL_DRAW_BUFFER11_ATI    0x8830
+#define GL_DRAW_BUFFER12_ATI    0x8831
+#define GL_DRAW_BUFFER13_ATI    0x8832
+#define GL_DRAW_BUFFER14_ATI    0x8833
+#define GL_DRAW_BUFFER15_ATI    0x8834
+
+typedef void (APIENTRY * PFNGLDRAWBUFFERS) (GLsizei n, const GLenum *bufs);
+
+extern PFNGLDRAWBUFFERS glDrawBuffersATI;
+
+#endif /* GL_ATI_draw_buffers */
+
+// added -ec
+/*-------------------------------------------------------------------*/
+/*------------GL_ATI_pixel_format_float------------------------------*/
+/*-------------------------------------------------------------------*/
+#ifndef WGL_ATI_pixel_format_float
+#define WGL_ATI_pixel_format_float
+
+#define WGL_RGBA_FLOAT_MODE_ATI                     0x8820
+#define WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI         0x8835
+#define WGL_TYPE_RGBA_FLOAT_ATI                     0x21A0
+    
+#endif /* WGL_ATI_pixel_format_float */
+
+/*-------------------------------------------------------------------*/
+/*------------END GL EXTENSIONS--------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------*/
+/*------------WGL EXTENSIONS HERE------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifdef _WIN32
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_EXT_EXTENSION_STRING-------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_EXT_extensions_string
+#define WGL_EXT_extensions_string 1
+
+typedef const char* (APIENTRY * wglGetExtensionsStringEXTPROC) ();
+
+extern wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT;
+
+#endif /* WGL_EXT_extensions_string */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_BUFFER_REGION----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_buffer_region
+#define WGL_ARB_buffer_region 1
+
+
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB                          0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB                           0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB                                0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB                              0x00000008
+
+typedef HANDLE (APIENTRY * wglCreateBufferRegionARBPROC) (HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (APIENTRY * wglDeleteBufferRegionARBPROC) (HANDLE hRegion);
+typedef BOOL (APIENTRY * wglSaveBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height);
+typedef BOOL (APIENTRY * wglRestoreBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+
+extern wglCreateBufferRegionARBPROC wglCreateBufferRegionARB;
+extern wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB;
+extern wglSaveBufferRegionARBPROC wglSaveBufferRegionARB;
+extern wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB;
+
+#endif /* WGL_ARB_buffer_region */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_EXTENSION_STRING-------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_extensions_string
+#define WGL_ARB_extensions_string 1
+
+typedef const char* (APIENTRY * wglGetExtensionsStringARBPROC) (HDC hdc);
+
+extern wglGetExtensionsStringARBPROC wglGetExtensionsStringARB;
+
+#endif /* WGL_ARB_extensions_string */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_PBUFFER----------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_pbuffer
+#define WGL_ARB_pbuffer 1
+
+#define WGL_DRAW_TO_PBUFFER_ARB                                 0x202D
+#define WGL_DRAW_TO_PBUFFER_ARB                                 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB                              0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB                               0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB                              0x2030
+#define WGL_PBUFFER_LARGEST_ARB                                 0x2033
+#define WGL_PBUFFER_WIDTH_ARB                                   0x2034
+#define WGL_PBUFFER_HEIGHT_ARB                                  0x2035
+#define WGL_PBUFFER_LOST_ARB                                    0x2036
+
+DECLARE_HANDLE(HPBUFFERARB);
+
+typedef HPBUFFERARB (APIENTRY * wglCreatePbufferARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (APIENTRY * wglGetPbufferDCARBPROC) (HPBUFFERARB hPbuffer);
+typedef int (APIENTRY * wglReleasePbufferDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (APIENTRY * wglDestroyPbufferARBPROC) (HPBUFFERARB hPbuffer);
+typedef BOOL (APIENTRY * wglQueryPbufferARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+
+extern wglCreatePbufferARBPROC wglCreatePbufferARB;
+extern wglGetPbufferDCARBPROC wglGetPbufferDCARB;
+extern wglReleasePbufferDCARBPROC wglReleasePbufferDCARB;
+extern wglDestroyPbufferARBPROC wglDestroyPbufferARB;
+extern wglQueryPbufferARBPROC wglQueryPbufferARB;
+
+#endif /* WGL_ARB_pbuffer */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_PIXEL_FORMAT-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_pixel_format
+#define WGL_ARB_pixel_format 1
+
+#define WGL_NUMBER_PIXEL_FORMATS_ARB                            0x2000
+#define WGL_DRAW_TO_WINDOW_ARB                                  0x2001
+#define WGL_DRAW_TO_BITMAP_ARB                                  0x2002
+#define WGL_ACCELERATION_ARB                                    0x2003
+#define WGL_NEED_PALETTE_ARB                                    0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB                             0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB                              0x2006
+#define WGL_SWAP_METHOD_ARB                                     0x2007
+#define WGL_NUMBER_OVERLAYS_ARB                                 0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB                                0x2009
+#define WGL_TRANSPARENT_ARB                                     0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB                           0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB                         0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB                          0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB                         0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB                         0x203B
+#define WGL_SHARE_DEPTH_ARB                                     0x200C
+#define WGL_SHARE_STENCIL_ARB                                   0x200D
+#define WGL_SHARE_ACCUM_ARB                                     0x200E
+#define WGL_SUPPORT_GDI_ARB                                     0x200F
+#define WGL_SUPPORT_OPENGL_ARB                                  0x2010
+#define WGL_DOUBLE_BUFFER_ARB                                   0x2011
+#define WGL_STEREO_ARB                                          0x2012
+#define WGL_PIXEL_TYPE_ARB                                      0x2013
+#define WGL_COLOR_BITS_ARB                                      0x2014
+#define WGL_RED_BITS_ARB                                        0x2015
+#define WGL_RED_SHIFT_ARB                                       0x2016
+#define WGL_GREEN_BITS_ARB                                      0x2017
+#define WGL_GREEN_SHIFT_ARB                                     0x2018
+#define WGL_BLUE_BITS_ARB                                       0x2019
+#define WGL_BLUE_SHIFT_ARB                                      0x201A
+#define WGL_ALPHA_BITS_ARB                                      0x201B
+#define WGL_ALPHA_SHIFT_ARB                                     0x201C
+#define WGL_ACCUM_BITS_ARB                                      0x201D
+#define WGL_ACCUM_RED_BITS_ARB                                  0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB                                0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB                                 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB                                0x2021
+#define WGL_DEPTH_BITS_ARB                                      0x2022
+#define WGL_STENCIL_BITS_ARB                                    0x2023
+#define WGL_AUX_BUFFERS_ARB                                     0x2024
+#define WGL_NO_ACCELERATION_ARB                                 0x2025
+#define WGL_GENERIC_ACCELERATION_ARB                            0x2026
+#define WGL_FULL_ACCELERATION_ARB                               0x2027
+#define WGL_SWAP_EXCHANGE_ARB                                   0x2028
+#define WGL_SWAP_COPY_ARB                                       0x2029
+#define WGL_SWAP_UNDEFINED_ARB                                  0x202A
+#define WGL_TYPE_RGBA_ARB                                       0x202B
+#define WGL_TYPE_COLORINDEX_ARB                                 0x202C
+
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribivARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribfvARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (APIENTRY * wglChoosePixelFormatARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+
+extern wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB;
+extern wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB;
+extern wglChoosePixelFormatARBPROC wglChoosePixelFormatARB;
+
+#endif /* WGL_ARB_pixel_format */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_RENDER_TEXTURE---------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_render_texture
+#define WGL_ARB_render_texture 1
+
+#define WGL_BIND_TO_TEXTURE_RGB_ARB                             0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB                            0x2071
+#define WGL_TEXTURE_FORMAT_ARB                                  0x2072
+#define WGL_TEXTURE_TARGET_ARB                                  0x2073
+#define WGL_MIPMAP_TEXTURE_ARB                                  0x2074
+#define WGL_TEXTURE_RGB_ARB                                     0x2075
+#define WGL_TEXTURE_RGBA_ARB                                    0x2076
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB                                0x2078
+#define WGL_TEXTURE_1D_ARB                                      0x2079
+#define WGL_TEXTURE_2D_ARB                                      0x207A
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_MIPMAP_LEVEL_ARB                                    0x207B
+#define WGL_CUBE_MAP_FACE_ARB                                   0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                     0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                     0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                     0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                     0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                     0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                     0x2082
+#define WGL_FRONT_LEFT_ARB                                      0x2083
+#define WGL_FRONT_RIGHT_ARB                                     0x2084
+#define WGL_BACK_LEFT_ARB                                       0x2085
+#define WGL_BACK_RIGHT_ARB                                      0x2086
+#define WGL_AUX0_ARB                                            0x2087
+#define WGL_AUX1_ARB                                            0x2088
+#define WGL_AUX2_ARB                                            0x2089
+#define WGL_AUX3_ARB                                            0x208A
+#define WGL_AUX4_ARB                                            0x208B
+#define WGL_AUX5_ARB                                            0x208C
+#define WGL_AUX6_ARB                                            0x208D
+#define WGL_AUX7_ARB                                            0x208E
+#define WGL_AUX8_ARB                                            0x208F
+#define WGL_AUX9_ARB                                            0x2090
+
+typedef BOOL (APIENTRY * wglBindTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (APIENTRY * wglReleaseTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (APIENTRY * wglSetPbufferAttribARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList);
+
+extern wglBindTexImageARBPROC wglBindTexImageARB;
+extern wglReleaseTexImageARBPROC wglReleaseTexImageARB;
+extern wglSetPbufferAttribARBPROC wglSetPbufferAttribARB;
+
+#endif /*WGL_ARB_render_texture */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_EXT_SWAP_CONTROL-----------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_EXT_swap_control
+#define WGL_EXT_swap_control 1
+
+typedef BOOL (APIENTRY * wglSwapIntervalEXTPROC) (int interval);
+typedef int (APIENTRY * wglGetSwapIntervalEXTPROC) (void);
+
+extern wglSwapIntervalEXTPROC wglSwapIntervalEXT;
+extern wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT;
+
+#endif /* WGL_EXT_swap_control */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_MAKE_CURRENT_READ------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_make_current_read
+#define WGL_ARB_make_current_read 1
+
+#define ERROR_INVALID_PIXEL_TYPE_ARB                            0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB	                0x2054
+
+typedef BOOL (APIENTRY * wglMakeContextCurrentARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC (APIENTRY * wglGetCurrentReadDCARBPROC) (void);
+
+extern wglMakeContextCurrentARBPROC wglMakeContextCurrentARB;
+extern wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB;
+
+#endif /* WGL_ARB_make_current_read */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_ARB_MULTISAMPLE------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_ARB_multisample
+#define WGL_ARB_multisample 1
+
+#define WGL_SAMPLE_BUFFERS_ARB                                  0x2041
+#define WGL_SAMPLES_ARB                                         0x2042
+
+#endif /* WGL_ARB_multisample */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_NV_RENDER_DEPTH_TEXTURE----------------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_NV_render_depth_texture
+#define WGL_NV_render_depth_texture 1
+
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV                            0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV                  0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV                             0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV                          0x20A6
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_DEPTH_COMPONENT_NV                                  0x20A7
+
+#endif /* WGL_NV_render_depth_texture */
+
+/*-------------------------------------------------------------------*/
+/*------------WGL_NV_RENDER_TEXTURE_RECTANGLE-----------------------*/
+/*-------------------------------------------------------------------*/
+
+#ifndef WGL_NV_render_texture_rectangle 
+#define WGL_NV_render_texture_rectangle 1
+
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV                    0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV                   0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV                                0x20A2
+
+#endif /* WGL_NV_render_texture_rectangle */
+
+/*-------------------------------------------------------------------*/
+/*------------END WGL EXTENSIONS-------------------------------------*/
+/*-------------------------------------------------------------------*/
+
+#endif /* WIN32 */
+
+/* helper stuff */
+
+/* I use int here because C does not know bool */
+
+#ifdef _WIN32
+
+struct WGLExtensionTypes
+{
+    int ARB_buffer_region;
+    int ARB_extensions_string;
+    int ARB_make_current_read;
+    int ARB_multisample;
+    int ARB_pbuffer;
+    int ARB_pixel_format;
+    int ARB_render_texture;
+    int EXT_extensions_string;
+    int EXT_swap_control;
+    int NV_render_depth_texture;
+    int NV_render_texture_rectangle;
+    int ATI_pixel_format_float;
+};
+
+#else /* No WIN32 */
+
+struct GLXExtensionTypes
+{
+
+};
+
+#endif /* WIN32 */
+
+struct ExtensionTypes
+{
+#ifdef _WIN32 /* WGL extensions */   
+    struct WGLExtensionTypes wgl;
+#else /* no WIN32 */
+    struct GLXExtensionTypes glx;
+#endif /* WIN32 */
+    int ARB_imaging;
+    int ARB_depth_texture;
+    int ARB_fragment_program;
+    int ARB_matrix_palette;
+    int ARB_multisample;
+    int ARB_multitexture;
+    int ARB_point_parameters;
+    int ARB_shadow;
+    int ARB_shadow_ambient;
+    int ARB_texture_border_clamp;
+    int ARB_texture_compression;
+    int ARB_texture_cube_map;
+    int ARB_texture_env_add;
+    int ARB_texture_env_dot3;
+    int ARB_texture_env_combine;
+    int ARB_texture_env_crossbar;
+    int ARB_texture_mirrored_repeat;
+    int ARB_transpose_matrix;
+    int ARB_vertex_blend;
+    int ARB_vertex_program;
+    int ARB_window_pos;
+    int EXT_abgr;
+    int EXT_bgra;
+    int EXT_blend_func_separate;
+    int EXT_compiled_vertex_array;
+    int EXT_cull_vertex;
+    int EXT_fog_coord;
+    int EXT_multi_draw_arrays;
+    int EXT_point_parameters;
+    int EXT_secondary_color;
+    int EXT_separate_specular_color;
+    int EXT_shadow_funcs;
+    int EXT_stencil_two_side;
+    int EXT_stencil_wrap;
+    int EXT_texture_compression_s3tc;
+    int EXT_texture_env_combine;
+    int EXT_texture_filter_anisotropic;
+    int EXT_texture_lod_bias;
+    int EXT_texture_rectangle; // added -ec
+    int EXT_vertex_shader;
+    int EXT_vertex_weighting;
+    int EXT_draw_range_elements;
+    int ATI_draw_buffers; // added -ec
+    int ATI_element_array;
+    int ATI_envmap_bumpmap;
+    int ATI_fragment_shader;
+    int ATI_pn_triangles;
+    int ATI_point_cull_mode;
+    int ATI_text_fragment_shader;
+    int ATI_texture_float; // added -ec
+    int ATI_texture_mirror_once;
+    int ATI_vertex_array_object;
+    int ATI_vertex_streams;
+    int ATIX_point_sprites;
+    int ATIX_texture_env_route;
+    int HP_occlusion_test;
+    int NV_blend_square;
+    int NV_copy_depth_to_color;
+    int NV_depth_clamp;
+    int NV_element_array;
+    int NV_evaluators;
+    int NV_fence;
+    int NV_float_buffer;
+    int NV_fog_distance;
+    int NV_fragment_program;
+    int NV_light_max_exponent;
+    int NV_occlusion_query;
+    int NV_packed_depth_stencil;
+    int NV_point_sprite;
+    int NV_primitive_restart;
+    int NV_register_combiners;
+    int NV_register_combiners2;
+    int NV_texgen_reflection;
+    int NV_texture_env_combine4;
+    int NV_texture_rectangle;
+    int NV_texture_shader;
+    int NV_texture_shader2;
+    int NV_texture_shader3;
+    int NV_vertex_array_range;
+    int NV_vertex_array_range2;
+    int NV_vertex_program;
+    int NV_vertex_program1_1;
+    int NV_vertex_program2;
+    int SGIS_generate_mipmap;
+    int SGIX_shadow;
+    int SGIX_depth_texture;
+    int OpenGL12;
+    int OpenGL13;
+    int OpenGL14;
+};
+
+extern struct ExtensionTypes extgl_Extensions;
+
+extern struct ExtensionTypes SupportedExtensions; /* deprecated, please do not use */
+
+/* initializes everything, call this right after the rc is created. the function returns 0 if successful */
+LIB_RENDERING_EXPORT
+int extgl_Initialize();
+
+LIB_RENDERING_EXPORT
+int glInitialize(); /* deprecated, please do not use */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __EXTGL_H__ */
diff --git a/source/blender/freestyle/intern/rendering/pbuffer.cpp b/source/blender/freestyle/intern/rendering/pbuffer.cpp
new file mode 100755
index 00000000000..0cb9013ddcd
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/pbuffer.cpp
@@ -0,0 +1,292 @@
+#include "pbuffer.h"
+
+#include <memory.h>
+
+#define MAX_PFORMATS 256
+#define MAX_ATTRIBS  32
+#define PBUFFER_AS_TEXTURE 2048
+
+//************************************************************
+// Implementation of PBuffer
+//************************************************************
+/*!
+ * Creates a PBuffer of size \p w by \p h, eith mode \p mode.
+ */
+PBuffer::PBuffer(const unsigned int w,
+		 const unsigned int h,
+		 const int format) 
+  : format_(format),
+    sharedContext_(false),
+    sharedLists_(false),
+    display_(NULL),
+    glxPbuffer_(0),
+    glxContext_(0), 
+    width_(w),
+    height_(h)
+{
+}    
+/*!
+ * Initialize the pbuffer. If \p shareContext is true, then the currently
+ * active context with be shared by the pbuffer, meaning for example that
+ * textures objects or display lists of the currently active GL context will
+ * be available to the pbuffer.  If you want it to be the case just for
+ * display lists, set \p sharedContext to false and \p shareLists to true.
+ * 
+ * This function is outside of the constructor for several reasons. First it
+ * might raise exceptions so it cannot be done in the constructor. Secondly,
+ * it is using the current context for sharing so you might want to create
+ * the pbuffer at a moment where this context is not yet active, and then
+ * initialise it once the context has been created and activated.
+ *
+ * Return false if creation failed.
+ */
+bool
+PBuffer::create(const bool shareContext, const bool shareLists)
+{
+  // Set display and screen
+  Display *pDisplay     = glXGetCurrentDisplay();
+  if (pDisplay == NULL)
+  {
+    pDisplay = XOpenDisplay(NULL);
+  }
+  int iScreen           = DefaultScreen(pDisplay);
+  GLXContext glxContext = glXGetCurrentContext();
+  
+  GLXFBConfig *glxConfig;
+  int iConfigCount;   
+    
+  sharedContext_ = shareContext;
+  sharedLists_ = shareLists;
+
+  if (sharedContext_)
+  {
+    glxConfig = glXGetFBConfigs(pDisplay, iScreen, &iConfigCount);
+    if (!glxConfig)
+    {
+//       "pbuffer creation error:  glXGetFBConfigs() failed"
+      return false;
+    }
+  }  
+  else
+  {
+    int iAttributes[2*MAX_ATTRIBS];
+    int curAttrib = 0;
+        
+    memset(iAttributes, 0, 2*MAX_ATTRIBS*sizeof(int));        
+            
+    iAttributes[2*curAttrib  ] = GLX_DRAWABLE_TYPE;
+    iAttributes[2*curAttrib+1] = GLX_PBUFFER_BIT;
+    curAttrib++;
+        
+    if (format_ & ColorIndex)
+    {
+      iAttributes[2*curAttrib  ] = GLX_RENDER_TYPE;
+      iAttributes[2*curAttrib+1] = GLX_COLOR_INDEX_BIT;
+      curAttrib++;
+    }
+    else
+    {
+      iAttributes[2*curAttrib  ] = GLX_RENDER_TYPE;
+      iAttributes[2*curAttrib+1] = GLX_RGBA_BIT;
+      iAttributes[2*curAttrib  ] = GLX_ALPHA_SIZE;
+      iAttributes[2*curAttrib+1] = 8;
+      curAttrib++;
+    }
+        
+    if (format_ & DoubleBuffer)
+    {
+      iAttributes[2*curAttrib  ] = GLX_DOUBLEBUFFER;
+      iAttributes[2*curAttrib+1] = true;
+      curAttrib++;
+    }
+    else
+    {
+      iAttributes[2*curAttrib  ] = GLX_DOUBLEBUFFER;
+      iAttributes[2*curAttrib+1] = false;
+      curAttrib++;
+    }  
+    if (format_ & DepthBuffer)
+    {
+      iAttributes[2*curAttrib  ] = GLX_DEPTH_SIZE;
+      iAttributes[2*curAttrib+1] = 1;
+      curAttrib++;
+    }
+    else
+    {
+      iAttributes[2*curAttrib  ] = GLX_DEPTH_SIZE;
+      iAttributes[2*curAttrib+1] = 0;
+      curAttrib++;
+    }    
+        
+    if (format_ & StencilBuffer)
+    {
+      iAttributes[2*curAttrib  ] = GLX_STENCIL_SIZE;
+      iAttributes[2*curAttrib+1] = 1;
+      curAttrib++;
+    }
+    else
+    {
+      iAttributes[2*curAttrib  ] = GLX_STENCIL_SIZE;
+      iAttributes[2*curAttrib+1] = 0;
+      curAttrib++;
+    }
+
+    iAttributes[2*curAttrib  ] = None;
+    
+    glxConfig = glXChooseFBConfigSGIX(pDisplay, iScreen, iAttributes, &iConfigCount);
+    if (!glxConfig)
+    {
+      // "pbuffer creation error:  glXChooseFBConfig() failed"
+      return false;
+    }
+  }
+   
+  int attributes[5];
+  int iCurAttrib = 0;
+    
+  memset(attributes, 0, 5*sizeof(int));
+
+  attributes[2*iCurAttrib  ] = GLX_LARGEST_PBUFFER;
+  attributes[2*iCurAttrib+1] = true;
+  iCurAttrib++;
+
+  attributes[2*iCurAttrib  ] = GLX_PRESERVED_CONTENTS;
+  attributes[2*iCurAttrib+1] = true;
+  iCurAttrib++;
+    
+  attributes[2*iCurAttrib  ] = None;
+
+  glxPbuffer_ = glXCreateGLXPbufferSGIX(pDisplay, glxConfig[0],
+					width_, height_, attributes);
+    
+  if (!glxPbuffer_)
+  {
+    // "pbuffer creation error:  glXCreatePbuffer() failed"
+    return false;
+  }
+    
+  if (sharedContext_)
+  {
+    glxContext_ = glxContext;
+  }
+  else
+  {
+    if (format_ & ColorIndex)
+    {
+      if (sharedLists_)
+	glxContext_ = glXCreateContextWithConfigSGIX(pDisplay,
+						     glxConfig[0],
+						     GLX_COLOR_INDEX_TYPE,
+						     glxContext, true);
+      else
+	glxContext_ = glXCreateContextWithConfigSGIX(pDisplay,
+						     glxConfig[0],
+						     GLX_COLOR_INDEX_TYPE,
+						     NULL, true);
+    }
+    else
+    {
+      if (sharedLists_)
+	glxContext_ = glXCreateContextWithConfigSGIX(pDisplay,
+						     glxConfig[0],
+						     GLX_RGBA_TYPE,
+						     glxContext, true);
+      else
+	glxContext_ = glXCreateContextWithConfigSGIX(pDisplay,
+						     glxConfig[0],
+						     GLX_RGBA_TYPE,
+						     NULL, true);
+    }
+
+    if (!glxConfig)
+    {
+      // "pbuffer creation error:  glXCreateNewContext() failed"
+      return false;
+    }
+  }
+
+  display_ = pDisplay;
+
+  glXQueryGLXPbufferSGIX(display_, glxPbuffer_, GLX_WIDTH, &width_);
+  glXQueryGLXPbufferSGIX(display_, glxPbuffer_, GLX_HEIGHT, &height_);
+
+  return true;
+}
+/*!
+ * Destroy the pbuffer
+ */
+PBuffer::~PBuffer()
+{
+  if (glxPbuffer_)
+  {
+    glXDestroyGLXPbufferSGIX(display_, glxPbuffer_);        
+  }
+}
+/*!
+ * Activate the pbuffer as the current GL context. All subsequents GL
+ * commands will now affect the pbuffer. If you want to push/pop the current
+ * OpenGL context use subclass PBufferEx instead.
+ *
+ * Return false if it failed.
+ */
+bool
+PBuffer::makeCurrent()
+{
+  return glXMakeCurrent(display_, glxPbuffer_, glxContext_);
+}
+/*!
+ * Return the width of the pbuffer
+ */
+unsigned int
+PBuffer::width() const
+{
+  return width_;
+}
+/*!
+ * Return the height of the pbuffer
+ */
+unsigned int
+PBuffer::height() const
+{
+  return height_;
+}
+//************************************************************
+// Implementation of PBufferEx
+//************************************************************
+PBufferEx::PBufferEx(const unsigned int width,
+		     const unsigned int height,
+		     const int mode)
+  : PBuffer(width, height, mode),
+    oldDisplay_(NULL),
+    glxOldDrawable_(0),
+    glxOldContext_(0)
+{
+}
+/*!
+ * Activate the pbuffer as the current GL context. All subsequents GL
+ * commands will now affect the pbuffer. Once you are done with you GL
+ * commands, you can call endCurrent() to restore the context that was active
+ * when you call makeCurrent().
+ *
+ * Return false if it failed.
+ */
+bool
+PBufferEx::makeCurrent()
+{
+  oldDisplay_ = glXGetCurrentDisplay();
+  glxOldDrawable_ = glXGetCurrentDrawable();
+  glxOldContext_ = glXGetCurrentContext();
+  
+  return PBuffer::makeCurrent();
+}
+/*!
+ * Restore the GL context that was active when makeCurrent() was called.
+ *
+ * Return false if it failed.
+ */
+bool
+PBufferEx::endCurrent()
+{
+  return glXMakeCurrent(oldDisplay_, glxOldDrawable_, glxOldContext_);
+}
+
diff --git a/source/blender/freestyle/intern/rendering/pbuffer.h b/source/blender/freestyle/intern/rendering/pbuffer.h
new file mode 100755
index 00000000000..35fd24484b6
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/pbuffer.h
@@ -0,0 +1,75 @@
+#ifndef PBUFFERS_H
+#define PBUFFERS_H
+
+# ifdef __MACH__
+#    include <OpenGL/gl.h>
+# else
+#    include <GL/gl.h>
+#    include <GL/glx.h>
+# endif
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Interface of PBuffer
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+class PBuffer
+{
+public:
+  enum FormatOption
+  {
+    DoubleBuffer            = 0x0001,
+    DepthBuffer             = 0x0002,
+    Rgba                    = 0x0004,
+    StencilBuffer           = 0x0020,
+    SingleBuffer            = DoubleBuffer  << 16,
+    NoDepthBuffer           = DepthBuffer   << 16,
+    ColorIndex              = Rgba          << 16,
+    NoStencilBuffer         = StencilBuffer << 16,
+  };
+     
+  PBuffer(const unsigned int width,
+	  const unsigned int height,
+	  int format);
+  bool create(const bool shareContext = false,
+	      const bool shareLists = false);
+  virtual ~PBuffer();
+  
+  virtual bool makeCurrent();
+  unsigned int width() const;
+  unsigned int height() const;
+protected:
+  ///! Flags indicating the type of pbuffer.
+  int          format_;
+  ///! Flag indicating if the rendering context is shared with another context.
+  bool         sharedContext_;
+  //! Flag indicating if display lists should be shared between rendering
+  // contexts.(If the rendering context is shared (default), then display
+  // lists are automatically shared).
+  bool         sharedLists_; 
+  Display*     display_;
+  GLXPbuffer   glxPbuffer_;
+  GLXContext   glxContext_;    
+  unsigned int width_;
+  unsigned int height_;
+};
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Interface of PBufferEx
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/*!
+ * pbuffer layer to keep previous pbuffer states.
+ */
+class PBufferEx : public PBuffer
+{
+public:
+  PBufferEx(const unsigned int width,
+	    const unsigned int height,
+	    const int mode );
+  virtual bool makeCurrent();
+  bool endCurrent();
+private:
+  Display*    oldDisplay_;
+  GLXDrawable glxOldDrawable_;
+  GLXContext  glxOldContext_;
+  int	      vp[4];
+};
+
+#endif //PBUFFERS_H
diff --git a/source/blender/freestyle/intern/rendering/rendering.pro b/source/blender/freestyle/intern/rendering/rendering.pro
new file mode 100755
index 00000000000..0bbca195b6b
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/rendering.pro
@@ -0,0 +1,102 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_RENDERING}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= opengl glut dll 
+
+exists (../libconfig.pri) {
+  include (../libconfig.pri)
+}
+
+#
+# DEFINES
+#
+#######################################
+
+#DEFINES         *= ROOT_DIR=\"$(FREESTYLE_DIR)\"
+win32:DEFINES   *= MAKE_LIB_RENDERING_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../scene_graph ../winged_edge ../view_map ../geometry \
+#                   ../stroke ../system ../image
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# LIBS
+#
+#######################################
+
+win32:LIBS      *= $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SCENE_GRAPH}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_WINGED_EDGE}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_VIEW_MAP}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_STROKE}$${LIBVERSION}.lib
+
+!win32 {
+    lib_bundle {
+      LIBS += -F$${DESTDIR} -framework $${LIB_GEOMETRY} \
+		-framework $${LIB_IMAGE} -framework $${LIB_SCENE_GRAPH} \
+		-framework $${LIB_SYSTEM} -framework $${LIB_WINGED_EDGE} \
+		-framework $${LIB_VIEW_MAP} -framework $${LIB_STROKE}
+    } else {
+      LIBS *= -L$${DESTDIR} -l$${LIB_GEOMETRY} -l$${LIB_IMAGE} -l$${LIB_SCENE_GRAPH} \
+                   -l$${LIB_SYSTEM} -l$${LIB_WINGED_EDGE} -l$${LIB_VIEW_MAP} -l$${LIB_STROKE}
+    }
+  }
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
+
+
+#
+# DEFINES
+# 
+#######################################
+!win32: DEFINES += GLX_GLXEXT_PROTOTYPES
diff --git a/source/blender/freestyle/intern/rendering/src.pri b/source/blender/freestyle/intern/rendering/src.pri
new file mode 100755
index 00000000000..aee4cdb2782
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/src.pri
@@ -0,0 +1,33 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+RENDERING_DIR = ../rendering
+
+SOURCES *= $${RENDERING_DIR}/GLBBoxRenderer.cpp \
+           $${RENDERING_DIR}/GLDebugRenderer.cpp \
+           $${RENDERING_DIR}/GLFreeMemoryVisitor.cpp \
+           $${RENDERING_DIR}/GLMonoColorRenderer.cpp \
+           $${RENDERING_DIR}/GLRenderer.cpp \
+           $${RENDERING_DIR}/GLSelectRenderer.cpp \
+           $${RENDERING_DIR}/GLStrokeRenderer.cpp \
+           $${RENDERING_DIR}/GLUtils.cpp 
+				     
+win32:SOURCES *= $${RENDERING_DIR}/extgl.cpp
+
+#!win32:SOURCES *= $${RENDERING_DIR}/pbuffer.cpp 
+				     
+HEADERS *= $${RENDERING_DIR}/GLBBoxRenderer.h \
+           $${RENDERING_DIR}/GLDebugRenderer.h \
+           $${RENDERING_DIR}/GLFreeMemoryVisitor.h \
+           $${RENDERING_DIR}/GLMonoColorRenderer.h \
+           $${RENDERING_DIR}/GLRenderer.h \
+           $${RENDERING_DIR}/GLSelectRenderer.h \
+           $${RENDERING_DIR}/GLStrokeRenderer.h \
+           $${RENDERING_DIR}/GLUtils.h 
+				     
+win32:HEADERS *= $${RENDERING_DIR}/extgl.h
+
+#!win32:HEADERS *= $${RENDERING_DIR}/pbuffer.h
+
diff --git a/source/blender/freestyle/intern/scene_graph/DrawingStyle.h b/source/blender/freestyle/intern/scene_graph/DrawingStyle.h
new file mode 100755
index 00000000000..58dcf4fede9
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/DrawingStyle.h
@@ -0,0 +1,82 @@
+//
+//  Filename         : DrawingStyle.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the drawing style of a node
+//  Date of creation : 10/10/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  DRAWINGSTYLE_H
+# define DRAWINGSTYLE_H
+
+class DrawingStyle
+{
+public:
+  enum STYLE
+  {FILLED, LINES, POINTS, INVISIBLE};
+  
+  inline DrawingStyle() {Style = FILLED; LineWidth = 2.f; PointSize = 2.f; LightingEnabled = true;}
+  inline explicit DrawingStyle(const DrawingStyle& iBrother);
+  
+  virtual ~DrawingStyle() {}
+
+  /*! operators */
+  inline DrawingStyle& operator=(const DrawingStyle& ds);
+  
+  inline void setStyle(const STYLE iStyle) {Style = iStyle;}
+  inline void setLineWidth(const float iLineWidth) {LineWidth = iLineWidth;}
+  inline void setPointSize(const float iPointSize) {PointSize = iPointSize;}
+  inline void setLightingEnabled(const bool on) {LightingEnabled = on;}
+
+  inline STYLE style() const {return Style;}
+  inline float lineWidth() const {return LineWidth;}
+  inline float pointSize() const {return PointSize;}
+  inline bool lightingEnabled() const {return LightingEnabled;}
+
+private:
+  STYLE Style;
+  float LineWidth;
+  float PointSize;
+  bool LightingEnabled;
+};
+
+DrawingStyle::DrawingStyle(const DrawingStyle& iBrother)
+{
+  Style           = iBrother.Style;
+  LineWidth       = iBrother.LineWidth;
+  PointSize       = iBrother.PointSize;
+  LightingEnabled = iBrother.LightingEnabled;
+}
+
+DrawingStyle& DrawingStyle::operator=(const DrawingStyle& ds)
+{
+  Style           = ds.Style;
+  LineWidth       = ds.LineWidth;
+  PointSize       = ds.PointSize;
+  LightingEnabled = ds.LightingEnabled;
+
+  return *this;
+}
+
+#endif // DRAWINGSTYLE_H
diff --git a/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.cpp b/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.cpp
new file mode 100755
index 00000000000..2604484ecd7
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.cpp
@@ -0,0 +1,321 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "IndexedFaceSet.h"
+
+IndexedFaceSet::IndexedFaceSet()
+: Rep()
+{
+  _Vertices = NULL;
+  _Normals = NULL;
+  _Materials = 0;
+  _TexCoords = 0;
+  _VSize = 0;
+  _NSize = 0;
+  _MSize = 0;
+  _TSize = 0;
+  _NumFaces = 0;
+  _NumVertexPerFace = NULL;
+  _FaceStyle = NULL;
+  _VIndices = NULL;
+  _VISize = 0;
+  _NIndices = NULL;
+  _NISize = 0;
+  _MIndices = NULL;
+  _MISize = 0;
+  _TIndices = NULL;
+  _TISize = 0;
+  _displayList = 0;
+}
+
+IndexedFaceSet::IndexedFaceSet( real *iVertices, unsigned iVSize, 
+                                real *iNormals, unsigned iNSize,
+                                Material **iMaterials, unsigned iMSize,
+                                real *iTexCoords, unsigned iTSize,
+                                unsigned iNumFaces, unsigned *iNumVertexPerFace, TRIANGLES_STYLE *iFaceStyle,
+                                unsigned *iVIndices, unsigned iVISize,
+                                unsigned *iNIndices, unsigned iNISize,
+                                unsigned *iMIndices, unsigned iMISize,
+                                unsigned *iTIndices, unsigned iTISize,
+                                unsigned iCopy)
+                                : Rep()
+{
+  if(1 == iCopy)
+  {
+    _VSize = iVSize;
+    _Vertices = new real[_VSize];
+    memcpy(_Vertices, iVertices, iVSize*sizeof(real));
+
+    _NSize = iNSize;
+    _Normals = new real[_NSize];
+    memcpy(_Normals, iNormals, iNSize*sizeof(real));
+
+    _MSize = iMSize;
+    _Materials = 0;
+	if(iMaterials){
+		_Materials = new Material*[_MSize];
+		for(unsigned i=0; i<_MSize; ++i)
+			_Materials[i] = new Material(*(iMaterials[i]));
+	}
+    _TSize = iTSize;
+    _TexCoords = 0;
+    if(_TSize){
+        _TexCoords = new real[_TSize];
+        memcpy(_TexCoords, iTexCoords, iTSize*sizeof(real));
+    }
+
+    _NumFaces = iNumFaces;
+    _NumVertexPerFace = new unsigned[_NumFaces];
+    memcpy(_NumVertexPerFace, iNumVertexPerFace, _NumFaces*sizeof(unsigned));
+
+    _FaceStyle = new TRIANGLES_STYLE[_NumFaces];
+    memcpy(_FaceStyle, iFaceStyle, _NumFaces*sizeof(TRIANGLES_STYLE));
+
+    _VISize = iVISize;
+    _VIndices = new unsigned[_VISize];
+    memcpy(_VIndices, iVIndices, _VISize*sizeof(unsigned));
+  
+    _NISize = iNISize;
+    _NIndices = new unsigned[_NISize];
+    memcpy(_NIndices, iNIndices, _NISize*sizeof(unsigned));
+
+    _MISize = iMISize;
+		_MIndices = 0;
+		if(iMIndices){
+			_MIndices = new unsigned[_MISize];
+			memcpy(_MIndices, iMIndices, _MISize*sizeof(unsigned));
+		}
+    _TISize = iTISize;
+    _TIndices = 0;
+    if(_TISize){
+        _TIndices = new unsigned[_TISize];
+        memcpy(_TIndices, iTIndices, _TISize*sizeof(unsigned));
+    }
+  }
+  else
+  {
+    _VSize = iVSize;
+    _Vertices = iVertices;
+
+    _NSize = iNSize;
+    _Normals = iNormals;
+
+    _MSize = iMSize;
+		_Materials = 0;
+		if(iMaterials)
+			_Materials = iMaterials;
+    
+    _TSize = iTSize;
+    _TexCoords = iTexCoords;
+
+    _NumFaces = iNumFaces;
+    _NumVertexPerFace = iNumVertexPerFace;
+    _FaceStyle = iFaceStyle;
+
+    _VISize = iVISize;
+    _VIndices = iVIndices;
+  
+    _NISize = iNISize;
+    _NIndices = iNIndices;
+    
+    _MISize = iMISize;
+		_MIndices = 0;
+		if(iMISize)
+			_MIndices = iMIndices;
+
+    _TISize = iTISize;
+    _TIndices = iTIndices;
+    }
+
+  _displayList = 0;
+}
+
+IndexedFaceSet::IndexedFaceSet( const IndexedFaceSet& iBrother)
+:Rep(iBrother)
+{
+  _VSize = iBrother.vsize();
+  _Vertices = new real[_VSize];
+  memcpy(_Vertices, iBrother.vertices(), _VSize*sizeof(real));
+  
+  _NSize = iBrother.nsize();
+  _Normals = new real[_NSize];
+  memcpy(_Normals, iBrother.normals(), _NSize*sizeof(real));
+
+  _MSize = iBrother.msize();
+	if(_MSize){
+		_Materials = new Material*[_MSize];
+		for(unsigned i=0; i<_MSize; ++i){
+			_Materials[i] = new Material(*(iBrother._Materials[i]));
+		}
+	}else{
+		_Materials = 0;
+	}
+
+    _TSize = iBrother.tsize();
+    _TexCoords  = 0;
+    if(_TSize){
+        _TexCoords = new real[_TSize];
+        memcpy(_TexCoords, iBrother.texCoords(), _TSize*sizeof(real));
+    }
+  
+  _NumFaces = iBrother.numFaces();
+  _NumVertexPerFace = new unsigned[_NumFaces];
+  memcpy(_NumVertexPerFace, iBrother.numVertexPerFaces(), _NumFaces*sizeof(unsigned));
+  
+  _FaceStyle = new TRIANGLES_STYLE[_NumFaces];
+  memcpy(_FaceStyle, iBrother.trianglesStyle(), _NumFaces*sizeof(TRIANGLES_STYLE));
+  
+  _VISize = iBrother.visize();
+  _VIndices = new unsigned[_VISize];
+  memcpy(_VIndices, iBrother.vindices(), _VISize*sizeof(unsigned));
+  
+  _NISize = iBrother.nisize();
+  _NIndices = new unsigned[_NISize];
+  memcpy(_NIndices, iBrother.nindices(), _NISize*sizeof(unsigned));
+
+  _MISize = iBrother.misize();
+	if(_MISize){
+		_MIndices = new unsigned[_MISize];
+		memcpy(_MIndices, iBrother.mindices(), _MISize*sizeof(unsigned));
+	}else{
+		_MIndices=0;
+	}
+
+    _TISize = iBrother.tisize();
+    _TIndices = 0;
+    if(_TISize){
+        _TIndices = new unsigned[_TISize];
+        memcpy(_TIndices, iBrother.tindices(), _TISize*sizeof(unsigned));
+    }
+
+  _displayList = 0;
+}
+
+IndexedFaceSet::~IndexedFaceSet()
+{
+  if(NULL != _Vertices)
+  {
+    delete [] _Vertices;
+    _Vertices = NULL;
+  }
+
+  if(NULL != _Normals)
+  {
+    delete [] _Normals;
+    _Normals = NULL;
+  }
+
+  if(NULL != _Materials)
+  {
+    for(unsigned i=0; i<_MSize; ++i)
+      delete _Materials[i];
+    delete [] _Materials;
+    _Materials = NULL;
+  }
+
+  if(NULL != _TexCoords)
+  {
+      delete [] _TexCoords;
+      _TexCoords = NULL;
+  }
+
+  if(NULL != _NumVertexPerFace)
+  {
+    delete [] _NumVertexPerFace;
+    _NumVertexPerFace = NULL;
+  }
+
+  if(NULL != _FaceStyle)
+  {
+    delete [] _FaceStyle;
+    _FaceStyle = NULL;
+  }
+
+  if(NULL != _VIndices)
+  {
+    delete [] _VIndices;
+    _VIndices = NULL;
+  }
+
+  if(NULL != _NIndices)
+  {
+    delete [] _NIndices;
+    _NIndices = NULL;
+  }
+
+  if(NULL != _MIndices)
+  {
+    delete [] _MIndices;
+    _MIndices = NULL;
+  }
+  if(NULL != _TIndices)
+  {
+      delete [] _TIndices;
+      _TIndices = NULL;
+  }
+  // should find a way to deallocates the displayList
+  // glDeleteLists(GLuint list, GLSizei range)
+  _displayList = 0;
+}
+
+void IndexedFaceSet::accept(SceneVisitor& v) {
+    Rep::accept(v);
+    v.visitIndexedFaceSet(*this);
+}
+
+void IndexedFaceSet::ComputeBBox()
+{
+  real XMax = _Vertices[0];
+  real YMax = _Vertices[1];
+  real ZMax = _Vertices[2];
+
+  real XMin = _Vertices[0];
+  real YMin = _Vertices[1];
+  real ZMin = _Vertices[2];
+
+  // parse all the coordinates to find 
+  // the Xmax, YMax, ZMax
+  real *v = _Vertices;
+
+  for(unsigned i=0; i<_VSize/3; i++)
+  {
+    // X
+    if(*v > XMax)
+      XMax = *v;
+    if(*v < XMin)
+      XMin = *v;
+    v++;
+
+    if(*v > YMax)
+      YMax = *v;
+    if(*v < YMin)
+      YMin = *v;
+    v++;
+
+    if(*v > ZMax)
+      ZMax = *v;
+    if(*v < ZMin)
+      ZMin = *v;
+    v++;
+  }
+
+  setBBox(BBox<Vec3r>(Vec3r(XMin, YMin, ZMin), Vec3r(XMax, YMax, ZMax)));
+}
diff --git a/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h b/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
new file mode 100755
index 00000000000..ce0afcd2fd6
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
@@ -0,0 +1,222 @@
+//
+//  Filename         : IndexedFaceSet.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : A Set of indexed faces to represent a surfacic object
+//  Date of creation : 22/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  INDEXEDFACESET_H
+# define INDEXEDFACESET_H
+
+# include <stdio.h>
+# include <memory.h>
+
+//! inherits from class Rep 
+# include "Rep.h"
+
+# include "../system/FreestyleConfig.h"
+
+class LIB_SCENE_GRAPH_EXPORT IndexedFaceSet : public Rep
+	{
+public:
+
+  /*! Triangles description style:*/
+  enum TRIANGLES_STYLE{TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES};
+
+  /*! Builds an empty indexed face set 
+  */
+  IndexedFaceSet();
+  /*! Builds an indexed face set 
+        iVertices
+          The array of object vertices 3D coordinates (for all faces).
+          If iCopy != 0, the array is copied; you must desallocate iVertices. Else you must not.
+        iVSize
+          The size of iVertices (must be a multiple of 3)
+        iNormals
+          The array of object normals 3D coordinates.
+          If iCopy != 0, the array is copied; you must desallocate iNormals. Else you must not.
+        iNSize
+          The size of iNormals
+        iMaterials
+          The array of materials
+        iMSize
+          The size of iMaterials
+        iTexCoords
+          The array of texture coordinates.
+        iTSize
+          The size of iTexCoords (must be multiple of 2)
+        iNumFaces
+          The number of faces
+        iNumVertexPerFace
+          Array containing the number of vertices per face.
+        iFaceStyle
+          Array containing the description style of each faces.
+          The style belongs to:
+          - TRIANGLE_STRIP: the face indices describe a triangle strip
+          - TRIANGLE_FAN  : the face indices describe a triangle fan
+          - TRIANGLES     : the face indices describe single triangles
+          If iCopy != 0, the array is copied; you must desallocate iFaceStyle. Else you must not.
+        iVIndices,
+          Array of vertices indices. 
+          The integers contained in this array must be multiple of 3.
+          If iCopy != 0, the array is copied; you must desallocate iVIndices. Else you must not.
+        iVISize
+          The size of iVIndices.
+        iNIndices
+          Array of normals indices. 
+          The integers contained in this array must be multiple of 3.
+          If iCopy != 0, the array is copied; you must desallocate iNIndices. Else you must not.
+        iNISize
+          The size of iNIndices
+        iMIndices
+          The Material indices (per vertex)
+        iMISize
+          The size of iMIndices
+        iTIndices
+          The Texture coordinates indices (per vertex). The integers contained in this array must be multiple of 2.
+        iTISize
+          The size of iMIndices
+        iCopy
+          0 : the arrays are not copied. The pointers passed as arguments are used. 
+              IndexedFaceSet takes these arrays desallocation in charge.
+          1 : the arrays are copied. The caller is in charge of the arrays, passed
+              as arguments desallocation.
+  */
+  IndexedFaceSet( real *iVertices, unsigned iVSize, 
+		  real *iNormals, unsigned iNSize,
+                  Material **iMaterials, unsigned iMSize,
+                  real *iTexCoords, unsigned iTSize,
+		  unsigned iNumFaces, unsigned *iNumVertexPerFace, TRIANGLES_STYLE *iFaceStyle,
+		  unsigned *iVIndices, unsigned iVISize,
+		  unsigned *iNIndices, unsigned iNISize,
+                  unsigned *iMIndices, unsigned iMISize,
+                  unsigned *iTIndices, unsigned iTISize,
+		  unsigned iCopy = 1
+		  );
+  
+  /*! Builds an indexed face set from an other indexed face set */
+  IndexedFaceSet(const IndexedFaceSet& iBrother);
+
+	void swap(IndexedFaceSet& ioOther){
+		std::swap(_Vertices, ioOther._Vertices);
+		std::swap(_Normals, ioOther._Normals);
+		std::swap(_Materials, ioOther._Materials);
+        std::swap(_TexCoords, ioOther._TexCoords);
+
+		std::swap(_VSize, ioOther._VSize);
+		std::swap(_NSize, ioOther._NSize);
+		std::swap(_MSize, ioOther._MSize);
+        std::swap(_TSize, ioOther._TSize);
+
+		std::swap(_NumFaces, ioOther._NumFaces);
+		std::swap(_NumVertexPerFace, ioOther._NumVertexPerFace);
+		std::swap(_FaceStyle, ioOther._FaceStyle);
+
+		std::swap(_VIndices, ioOther._VIndices);
+		std::swap(_NIndices, ioOther._NIndices);
+		std::swap(_MIndices, ioOther._MIndices); // Material Indices
+        std::swap(_TIndices, ioOther._TIndices);
+
+		std::swap(_VISize, ioOther._VISize);
+		std::swap(_NISize, ioOther._NISize);
+		std::swap(_MISize, ioOther._MISize);
+        std::swap(_TISize, ioOther._TISize);
+
+		std::swap(_displayList, ioOther._displayList);
+
+		Rep::swap(ioOther);
+	}
+
+	IndexedFaceSet& operator=(const IndexedFaceSet& iBrother){
+		IndexedFaceSet tmp(iBrother);
+		swap(tmp);
+		return *this;
+	}
+
+  /*! Desctructor 
+      desallocates all the ressources */
+  virtual ~IndexedFaceSet();
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! Compute the Bounding Box */
+  virtual void ComputeBBox();
+
+  /*! modifiers */
+  inline void setDisplayList(unsigned int index) {_displayList = index;}
+
+  /*! Accessors */
+  virtual const real * vertices() const {return _Vertices;}
+  virtual const real * normals() const {return _Normals;}
+  virtual const Material*const* materials() const {return _Materials;}
+  virtual const real* texCoords() const {return _TexCoords;}
+  virtual const unsigned vsize() const {return _VSize;}
+  virtual const unsigned nsize() const {return _NSize;}
+  virtual const unsigned msize() const {return _MSize;}
+  virtual const unsigned tsize() const {return _TSize;}
+  virtual const unsigned numFaces() const {return _NumFaces;}
+  virtual const unsigned * numVertexPerFaces() const {return _NumVertexPerFace;}
+  virtual const TRIANGLES_STYLE * trianglesStyle() const {return _FaceStyle;}
+  virtual const unsigned* vindices() const {return _VIndices;}
+  virtual const unsigned* nindices() const {return _NIndices;}
+  virtual const unsigned* mindices() const {return _MIndices;}
+  virtual const unsigned* tindices() const {return _TIndices;}
+  virtual const unsigned visize() const {return _VISize;}
+  virtual const unsigned nisize() const {return _NISize;}
+  virtual const unsigned misize() const {return _MISize;}
+  virtual const unsigned tisize() const {return _TISize;}
+  inline unsigned int displayList() const {return _displayList;}
+
+protected:
+  real *_Vertices;
+  real *_Normals;
+  Material** _Materials;
+  real *_TexCoords;
+  
+  unsigned _VSize;
+  unsigned _NSize;
+  unsigned _MSize;
+  unsigned _TSize;
+
+  unsigned _NumFaces;
+  unsigned *_NumVertexPerFace;
+  TRIANGLES_STYLE *_FaceStyle;
+
+  unsigned *_VIndices;
+  unsigned *_NIndices;
+  unsigned *_MIndices; // Material Indices
+  unsigned *_TIndices; // Texture coordinates Indices
+  
+  unsigned _VISize;
+  unsigned _NISize;
+  unsigned _MISize;
+  unsigned _TISize;
+
+  unsigned int _displayList;
+
+};
+
+#endif // INDEXEDFACESET_H
diff --git a/source/blender/freestyle/intern/scene_graph/LineRep.cpp b/source/blender/freestyle/intern/scene_graph/LineRep.cpp
new file mode 100755
index 00000000000..504db06acf4
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/LineRep.cpp
@@ -0,0 +1,58 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "LineRep.h"
+
+void LineRep::ComputeBBox()
+{
+  real XMax = _vertices.front()[0];
+  real YMax = _vertices.front()[1];
+  real ZMax = _vertices.front()[2];
+
+  real XMin = _vertices.front()[0];
+  real YMin = _vertices.front()[1];
+  real ZMin = _vertices.front()[2];
+
+  // parse all the coordinates to find 
+  // the XMax, YMax, ZMax
+  vector<Vec3r>::iterator v;
+  for(v=_vertices.begin(); v!=_vertices.end(); v++) {
+    // X
+    if((*v)[0] > XMax)
+      XMax = (*v)[0];
+    if((*v)[0] < XMin)
+      XMin = (*v)[0];
+
+    // Y
+    if((*v)[1] > YMax)
+      YMax = (*v)[1];
+    if((*v)[1] < YMin)
+      YMin = (*v)[1];
+
+    // Z
+    if((*v)[2] > ZMax)
+      ZMax = (*v)[2];
+    if((*v)[2] < ZMin)
+      ZMin = (*v)[2];
+  }
+
+  setBBox(BBox<Vec3r>(Vec3r(XMin, YMin, ZMin), Vec3r(XMax, YMax, ZMax)));
+}
diff --git a/source/blender/freestyle/intern/scene_graph/LineRep.h b/source/blender/freestyle/intern/scene_graph/LineRep.h
new file mode 100755
index 00000000000..232557af857
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/LineRep.h
@@ -0,0 +1,130 @@
+//
+//  Filename         : LineRep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the representation of 3D Line.
+//  Date of creation : 26/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  LINEREP_H
+# define LINEREP_H
+
+# include <vector>
+# include <list>
+# include "Rep.h"
+# include "../system/FreestyleConfig.h"
+
+using namespace std;
+
+/*! Base class for all lines objects */
+class LIB_SCENE_GRAPH_EXPORT LineRep : public Rep
+{
+public:
+  
+  /*! Line description style */
+  enum LINES_STYLE{LINES, LINE_STRIP, LINE_LOOP};
+  inline LineRep() : Rep() {_width = 0.f;}
+
+  /*! Builds a single line from 2 vertices
+   *  v1
+   *    first vertex
+   *  v2
+   *    second vertex
+   */
+  inline LineRep(const Vec3r& v1, const Vec3r& v2)
+    : Rep()
+  {
+    setStyle(LINES);
+    AddVertex(v1);
+    AddVertex(v2);
+    _width = 0.f;
+  }
+
+  /*! Builds a line rep from a vertex chain */
+  inline LineRep(const vector<Vec3r>& vertices)
+    : Rep()
+  {
+    _vertices = vertices;
+    setStyle(LINE_STRIP);
+    _width = 0.f;
+  }
+
+  /*! Builds a line rep from a vertex chain */
+  inline LineRep(const list<Vec3r>& vertices)
+    : Rep()
+  {
+    for(list<Vec3r>::const_iterator v=vertices.begin(), end=vertices.end();
+    v!=end;
+    v++)
+    {
+      _vertices.push_back(*v);
+    }
+    setStyle(LINE_STRIP);
+    _width = 0.f;
+  }
+
+  virtual ~LineRep() 
+  {
+  _vertices.clear();
+  } 
+
+  /*! accessors */
+  inline const LINES_STYLE style() const {return _Style;}
+  inline const vector<Vec3r>& vertices() const {return _vertices;}
+  inline float width() const {return _width;}
+
+  /*! modifiers */
+  inline void setStyle(const LINES_STYLE iStyle) {_Style = iStyle;}
+  inline void AddVertex(const Vec3r& iVertex) {_vertices.push_back(iVertex);}
+  inline void setVertices(const vector<Vec3r>& iVertices)
+  {
+    if(0 != _vertices.size())
+    {
+      _vertices.clear();
+    }
+    for(vector<Vec3r>::const_iterator v=iVertices.begin(), end=iVertices.end();
+        v!=end;
+        v++)
+        {
+          _vertices.push_back(*v);
+        }
+  }
+  inline void setWidth(float iWidth) {_width=iWidth;}
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v) {
+    Rep::accept(v);
+    v.visitLineRep(*this);
+  }
+
+  /*! Computes the line bounding box.*/
+  virtual void ComputeBBox();
+
+private:
+  LINES_STYLE _Style;
+  vector<Vec3r> _vertices;
+  float _width;
+};
+
+#endif // LINEREP_H
diff --git a/source/blender/freestyle/intern/scene_graph/Material.h b/source/blender/freestyle/intern/scene_graph/Material.h
new file mode 100755
index 00000000000..64ae526ccb0
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/Material.h
@@ -0,0 +1,304 @@
+//
+//  Filename         : Material.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class used to handle materials.
+//  Date of creation : 10/10/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  MATERIAL_H
+# define MATERIAL_H
+
+# include "../system/FreestyleConfig.h"
+
+/*! Class defining a material */
+class Material
+{
+public:
+  /*! Default constructor */
+  inline Material();
+  /*! Builds a Material from its diffuse, ambiant, specular, emissive
+   *  colors and a shininess coefficient.
+   *    \param iDiffuse
+   *      A 4 element float-array containing the diffuse color.
+   *    \param iAmbiant
+   *      A 4 element float-array containing the ambiant color.
+   *    \param iSpecular
+   *      A 4 element float-array containing the specular color.
+   *    \param iEmission
+   *      A 4 element float-array containing the emissive color.
+   *    \param iShininess
+   *      The shininess coefficient.
+   */
+  inline Material(const float *iDiffuse,
+                  const float *iAmbiant,
+                  const float *iSpecular, 
+                  const float *iEmission, 
+                  const float iShininess);
+
+  /*! Copy constructor */
+  inline Material(const Material& m);
+  /*! Destructor */
+  virtual ~Material() {}
+
+
+  /*! Returns the diffuse color as a 4 float array */
+  inline const float * diffuse() const { return Diffuse; }
+  /*! Returns the red component of the diffuse color */
+  inline const float   diffuseR() const { return Diffuse[0]; }
+  /*! Returns the green component of the diffuse color */
+  inline const float   diffuseG() const { return Diffuse[1]; }
+  /*! Returns the blue component of the diffuse color */
+  inline const float   diffuseB() const { return Diffuse[2]; }
+  /*! Returns the alpha component of the diffuse color */
+  inline const float   diffuseA() const { return Diffuse[3]; }
+
+  /*! Returns the specular color as a 4 float array */
+  inline const float * specular() const { return Specular; }
+  /*! Returns the red component of the specular color */
+  inline const float   specularR() const { return Specular[0]; }
+  /*! Returns the green component of the specular color */
+  inline const float   specularG() const { return Specular[1]; }
+  /*! Returns the blue component of the specular color */
+  inline const float   specularB() const { return Specular[2]; }
+  /*! Returns the alpha component of the specular color */
+  inline const float   specularA() const { return Specular[3]; }
+
+  /*! Returns the ambiant color as a 4 float array */
+  inline const float * ambient() const { return Ambient; }
+  /*! Returns the red component of the ambiant color */
+  inline const float   ambientR() const { return Ambient[0]; }
+  /*! Returns the green component of the ambiant color */
+  inline const float   ambientG() const { return Ambient[1]; }
+  /*! Returns the blue component of the ambiant color */
+  inline const float   ambientB() const { return Ambient[2]; }
+  /*! Returns the alpha component of the ambiant color */
+  inline const float   ambientA() const { return Ambient[3]; }
+
+  /*! Returns the emissive color as a 4 float array */
+  inline const float * emission() const { return Emission; }
+  /*! Returns the red component of the emissive color */
+  inline const float   emissionR() const { return Emission[0]; }
+  /*! Returns the green component of the emissive color */
+  inline const float   emissionG() const { return Emission[1]; }
+  /*! Returns the blue component of the emissive color */
+  inline const float   emissionB() const { return Emission[2]; }
+  /*! Returns the alpha component of the emissive color */
+  inline const float   emissionA() const { return Emission[3]; }
+
+  /*! Returns the shininess coefficient */
+  inline const float shininess() const { return Shininess; }
+
+  /*! Sets the diffuse color.
+   *    \param r
+   *      Red component
+   *    \param g
+   *      Green component
+   *    \param b
+   *     Blue component
+   *    \param a
+   *      Alpha component
+   */
+  inline void setDiffuse(const float r, const float g, const float b, const float a);
+  /*! Sets the specular color.
+   *    \param r
+   *      Red component
+   *    \param g
+   *      Green component
+   *    \param b
+   *     Blue component
+   *    \param a
+   *      Alpha component
+   */
+  inline void setSpecular(const float r, const float g, const float b, const float a);
+  /*! Sets the ambiant color.
+   *    \param r
+   *      Red component
+   *    \param g
+   *      Green component
+   *    \param b
+   *     Blue component
+   *    \param a
+   *      Alpha component
+   */
+  inline void setAmbient(const float r, const float g, const float b, const float a);
+
+  /*! Sets the emissive color.
+   *    \param r
+   *      Red component
+   *    \param g
+   *      Green component
+   *    \param b
+   *     Blue component
+   *    \param a
+   *      Alpha component
+   */
+  inline void setEmission(const float r, const float g, const float b, const float a);
+
+  /*! Sets the shininess.
+   *    \param s
+   *      Shininess
+   */
+  inline void setShininess(const float s);
+
+  /* operators */
+  inline Material& operator=(const Material& m);
+  inline bool operator!=(const Material& m) const;
+  inline bool operator==(const Material& m) const;
+
+private:
+
+  /*! Material properties */
+  float Diffuse[4];
+  float Specular[4];
+  float Ambient[4];
+  float Emission[4];
+  float Shininess;
+
+};
+
+Material::Material()
+{
+  Ambient[0] = Ambient[1] = Ambient[2] = 0.2f;
+  Ambient[3] = 1.f;
+
+  Diffuse[0] = Diffuse[1] = Diffuse[2] = 0.8f;
+  Diffuse[3] = 1.f;
+
+  Emission[0] = Emission[1] = Emission[2] = 0.f;
+  Emission[3] = 1.f;
+
+  Specular[0] = Specular[1] = Specular[2] = 0.f;
+  Specular[3] = 1.f;
+
+  Shininess = 0.f;
+}
+
+Material::Material(const float *iDiffuse,
+                   const float *iAmbiant,
+                   const float *iSpecular, 
+                   const float *iEmission, 
+                   const float iShininess)
+{
+  for(int i=0; i<4; i++)
+  {
+    Diffuse[i]  = iDiffuse[i];
+    Specular[i] = iSpecular[i];
+    Ambient[i]  = iAmbiant[i];
+    Emission[i] = iEmission[i];
+  }
+
+  Shininess = iShininess;
+}
+
+Material::Material(const Material& m)
+{
+  for(int i=0; i<4; i++)
+  {
+    Diffuse[i]  = m.diffuse()[i];
+    Specular[i] = m.specular()[i];
+    Ambient[i]  = m.ambient()[i];
+    Emission[i] = m.emission()[i];
+  }
+
+  Shininess = m.shininess();
+}
+
+void Material::setDiffuse(const float r, const float g, const float b, const float a)
+{
+  Diffuse[0] = r;
+  Diffuse[1] = g;
+  Diffuse[2] = b;
+  Diffuse[3] = a;
+}
+
+void Material::setSpecular(const float r, const float g, const float b, const float a)
+{
+  Specular[0] = r;
+  Specular[1] = g;
+  Specular[2] = b;
+  Specular[3] = a;
+}
+  
+void Material::setAmbient(const float r, const float g, const float b, const float a)
+{
+  Ambient[0] = r;
+  Ambient[1] = g;
+  Ambient[2] = b;
+  Ambient[3] = a;
+}
+
+void Material::setEmission(const float r, const float g, const float b, const float a)
+{
+  Emission[0] = r;
+  Emission[1] = g;
+  Emission[2] = b;
+  Emission[3] = a;
+}
+
+void Material::setShininess(const float s)
+{
+  Shininess = s;
+}
+
+Material& Material::operator=(const Material& m)
+{
+  for(int i=0; i<4; i++)
+  {
+    Diffuse[i]  = m.diffuse()[i];
+    Specular[i] = m.specular()[i];
+    Ambient[i]  = m.ambient()[i];
+    Emission[i] = m.emission()[i];
+  }
+
+  Shininess = m.shininess();
+
+  return *this;
+}
+
+bool Material::operator!=(const Material& m) const
+{
+  if(Shininess != m.shininess())
+    return true;
+  for(int i=0; i<4; i++)
+  {
+    if(Diffuse[i]  != m.diffuse()[i])
+      return true;
+    if(Specular[i] != m.specular()[i])
+      return true;
+    if(Ambient[i]  != m.ambient()[i])
+      return true;
+    if(Emission[i] != m.emission()[i])
+      return true;
+  }
+
+  return false;
+}
+
+bool Material::operator==(const Material& m) const
+{
+  return (!((*this)!=m));
+}
+
+#endif // MATERIAL_H
diff --git a/source/blender/freestyle/intern/scene_graph/MaxFileLoader.cpp b/source/blender/freestyle/intern/scene_graph/MaxFileLoader.cpp
new file mode 100755
index 00000000000..a6d3b8f8721
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/MaxFileLoader.cpp
@@ -0,0 +1,388 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "MaxFileLoader.h"
+
+MaxFileLoader::MaxFileLoader()
+{
+  _FileName = NULL;
+  _3dsFile = NULL;
+  _Scene = NULL;
+  _numFacesRead = 0;
+  _minEdgeSize = DBL_MAX;
+}
+
+MaxFileLoader::MaxFileLoader(const char *iFileName)
+{
+  _FileName = new char[strlen(iFileName)+1];
+  strcpy(_FileName, iFileName);
+
+  _3dsFile = NULL;
+  _Scene = NULL;
+  _numFacesRead = 0;
+  _minEdgeSize = DBL_MAX;
+}
+
+MaxFileLoader::~MaxFileLoader()
+{
+  if(NULL != _FileName)
+  {
+    delete [] _FileName;
+    _FileName = NULL;
+  }
+
+  if(NULL != _3dsFile)
+  {
+    lib3ds_file_free(_3dsFile);
+    _3dsFile = NULL;
+  }
+
+  _Scene = NULL;
+}
+
+void MaxFileLoader::setFileName(const char *iFileName)
+{
+  if(NULL != _FileName)
+    delete [] _FileName;
+
+  _FileName = new char[strlen(iFileName)+1];
+  strcpy(_FileName, iFileName);
+}
+
+NodeGroup* MaxFileLoader::Load()
+{
+  _3dsFile=lib3ds_file_load(_FileName);
+  if(NULL == _3dsFile)
+    return NULL;
+
+	/* No nodes?  Fabricate nodes to display all the meshes. */
+  if( !_3dsFile->nodes )
+  {
+    Lib3dsMesh *mesh;
+    Lib3dsNode *node;
+
+    for(mesh = _3dsFile->meshes; mesh != NULL; mesh = mesh->next)
+    {
+      node = lib3ds_node_new_object();
+      strcpy(node->name, mesh->name);
+      node->parent_id = LIB3DS_NO_PARENT;
+      node->data.object.scl_track.keyL = lib3ds_lin3_key_new();
+      node->data.object.scl_track.keyL->value[0] = 1.;
+      node->data.object.scl_track.keyL->value[1] = 1.;
+      node->data.object.scl_track.keyL->value[2] = 1.;
+      lib3ds_file_insert_node(_3dsFile, node);
+    }
+  }
+
+  lib3ds_file_eval(_3dsFile, 0);
+  
+  // creation of the scene root node
+  _Scene = new NodeGroup;
+
+  // converts the 3ds format to the scene format
+  // the RenderNode method modifies _Scene.
+  Lib3dsNode *p;
+  for (p=_3dsFile->nodes; p!=0; p=p->next) {
+    RenderNode(p);
+  }
+  //Returns the built scene.
+  return _Scene;
+}
+
+void lib3ds_normal_transform(Lib3dsVector c, Lib3dsMatrix m, Lib3dsVector a)
+{
+  c[0]= (m[0][0]*a[0] + m[1][0]*a[1] + m[2][0]*a[2]);
+  c[1]= (m[0][1]*a[0] + m[1][1]*a[1] + m[2][1]*a[2]);
+  c[2]= (m[0][2]*a[0] + m[1][2]*a[1] + m[2][2]*a[2]);
+
+  //  c[0]= (m[0][0]*a[0] + m[1][0]*a[1] + m[2][0]*a[2])/m[0][0];
+  //  c[1]= (m[0][1]*a[0] + m[1][1]*a[1] + m[2][1]*a[2])/m[1][1];
+  //  c[2]= (m[0][2]*a[0] + m[1][2]*a[1] + m[2][2]*a[2])/m[2][2];
+
+  //lib3ds_vector_normalize(c);
+
+  //  c[0] = c[0]*m[0][0];
+  //  c[1] = c[1]*m[1][1];
+  //  c[2] = c[2]*m[2][2];
+
+}
+
+
+
+void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
+{
+  Lib3dsNode *p;
+  for (p=iNode->childs; p!=0; p=p->next) 
+    RenderNode(p);
+
+  float minBBox[3];
+  float maxBBox[3];
+  if (iNode->type==LIB3DS_OBJECT_NODE) 
+  {
+    if (strcmp(iNode->name,"$$$DUMMY")==0) 
+      return;
+
+    NodeTransform *currentMesh = new NodeTransform;
+    NodeShape * shape;
+    
+    if (!iNode->user.d) // If the shape is not built yet, just do it !
+    {
+      Lib3dsMesh *mesh=lib3ds_file_mesh_by_name(_3dsFile, iNode->name);
+      ASSERT(mesh);
+      if (!mesh) 
+        return;
+
+      // builds the shape:
+      shape = new NodeShape;
+      iNode->user.d=(unsigned long)shape; // We store as user data the NodeShape address
+
+      // We invert the matrix in order to 
+      // be able to retrieve the shape's coordinates 
+      // in its local coordinates system (origin is the iNode pivot)
+      Lib3dsMatrix M;
+      lib3ds_matrix_copy(M, mesh->matrix);
+      lib3ds_matrix_inv(M);
+      
+      // We compute a normal per vertex and manages the smoothing of the shape:
+      Lib3dsVector *normalL=(Lib3dsVector*)malloc(3*sizeof(Lib3dsVector)*mesh->faces);
+      lib3ds_mesh_calculate_normals(mesh, normalL);
+
+      // We build the rep:
+      IndexedFaceSet *rep;
+      unsigned numFaces = mesh->faces;
+      
+      unsigned vSize = 3*3*numFaces;
+      float *vertices = new float[vSize];
+      unsigned nSize = vSize;
+      float *normals = new float[nSize];
+      unsigned *numVertexPerFaces = new unsigned[numFaces];
+      vector<Material> meshMaterials;
+
+      IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
+      unsigned i;
+      for (i = 0; i <numFaces; i++) {
+        faceStyle[i] = IndexedFaceSet::TRIANGLES;
+        numVertexPerFaces[i] = 3;
+      }
+      
+      unsigned viSize = 3*numFaces;
+      unsigned *VIndices = new unsigned[viSize];
+      unsigned niSize = viSize;
+      unsigned *NIndices = new unsigned[niSize];
+      unsigned *MIndices = new unsigned[viSize]; // Material Indices
+     
+
+      float *pv = vertices;
+      float *pn = normals;
+      unsigned *pvi = VIndices;
+      unsigned *pni = NIndices;
+      unsigned *pmi = MIndices;
+      
+      unsigned currentIndex = 0;
+      unsigned currentMIndex = 0;
+
+      Material tmpMat;
+      
+      // we want to find the min and max coordinates as we build the rep. 
+      // We initialize the min and max values whith the first vertex.
+      float pvtmp[3];
+      lib3ds_vector_transform(pvtmp, M, mesh->pointL[mesh->faceL[0].points[0]].pos);
+      minBBox[0] = pvtmp[0];
+      maxBBox[0] = pvtmp[0];
+      minBBox[1] = pvtmp[1];
+      maxBBox[1] = pvtmp[1];
+      minBBox[2] = pvtmp[2];
+      maxBBox[2] = pvtmp[2];
+
+      unsigned p;
+      real vert[3][3];
+      real norm;
+      for(p=0; p<mesh->faces; ++p) // we parse the faces of the mesh
+      {
+        Lib3dsFace *f=&mesh->faceL[p];
+        Lib3dsMaterial *mat=0;
+        if (f->material[0]) 
+          mat=lib3ds_file_material_by_name(_3dsFile, f->material);
+
+        if (mat) 
+        {
+          tmpMat.setDiffuse(mat->diffuse[0], mat->diffuse[1], mat->diffuse[2], mat->diffuse[3]);
+          tmpMat.setSpecular(mat->specular[0], mat->specular[1], mat->specular[2], mat->specular[3]);
+          float s = (float)pow(2.0, 10.0*mat->shininess);
+          if(s > 128.f)
+            s = 128.f;
+          tmpMat.setShininess(s);
+        }
+        
+        if(meshMaterials.empty()){
+          meshMaterials.push_back(tmpMat);
+          shape->setMaterial(tmpMat);
+        }else{
+          // find if the material is aleady in the list
+          unsigned i=0;
+          bool found = false;
+          for(vector<Material>::iterator it=meshMaterials.begin(), itend=meshMaterials.end();
+          it!=itend;
+          ++it){
+            if(*it == tmpMat){
+              currentMIndex = i;
+              found = true;
+              break;
+            }
+            ++i;
+          }
+          if(!found){
+            meshMaterials.push_back(tmpMat);
+            currentMIndex = meshMaterials.size()-1;
+          }
+        }
+        
+
+        for(i=0; i<3; ++i) // we parse the vertices of the face f
+        {
+          unsigned j;
+          lib3ds_vector_transform(pv, M, mesh->pointL[f->points[i]].pos); //fills the cells of the pv array
+          for(j=0; j<3; j++) // we parse the xyz coordinates of the vertex i
+          {
+            if(minBBox[j] > pv[j])
+              minBBox[j] = pv[j];
+
+            if(maxBBox[j] < pv[j])
+              maxBBox[j] = pv[j];
+
+            vert[i][j] = pv[j];
+          }
+          
+          for(j=0; j<3; j++)
+            pn[j] = f->normal[j];
+
+          lib3ds_normal_transform(pn, M, normalL[3*p+i]); //fills the cells of the pv array
+          //lib3ds_vector_normalize(pn);
+
+          
+          *pvi = currentIndex;
+          *pni = currentIndex;
+          *pmi = currentMIndex;
+          
+
+          currentIndex +=3;
+          pv += 3;
+          pn += 3;
+          pvi++;
+          pni++;
+          pmi++;
+          
+        }
+
+        for(i=0; i<3; i++)
+        {
+          norm = 0.0;
+          for (unsigned j = 0; j < 3; j++)
+            norm += (vert[i][j] - vert[(i+1)%3][j])*(vert[i][j] - vert[(i+1)%3][j]);
+          norm = sqrt(norm);
+          if(_minEdgeSize > norm)
+            _minEdgeSize = norm;
+        }
+
+        _numFacesRead++;
+      }
+
+      free(normalL);
+
+      // We might have several times the same vertex. We want a clean 
+      // shape with no real-vertex. Here, we are making a cleaning 
+      // pass.
+      real *cleanVertices = NULL;
+      unsigned   cvSize;
+      unsigned   *cleanVIndices = NULL;
+      
+      GeomCleaner::CleanIndexedVertexArray(
+        vertices, vSize, 
+        VIndices, viSize,
+        &cleanVertices, &cvSize, 
+        &cleanVIndices);
+
+      real *cleanNormals = NULL;
+      unsigned   cnSize;
+      unsigned   *cleanNIndices = NULL;
+
+      GeomCleaner::CleanIndexedVertexArray(
+        normals, nSize, 
+        NIndices, niSize,
+        &cleanNormals, &cnSize, 
+        &cleanNIndices);
+
+      // format materials array
+      Material** marray = new Material*[meshMaterials.size()];
+      unsigned mindex=0;
+      for(vector<Material>::iterator m=meshMaterials.begin(), mend=meshMaterials.end();
+          m!=mend;
+          ++m){
+        marray[mindex] = new Material(*m);
+        ++mindex;
+      }
+      // deallocates memory:
+      delete [] vertices;
+      delete [] normals;
+      delete [] VIndices;
+      delete [] NIndices;
+      
+      // Create the IndexedFaceSet with the retrieved attributes
+      rep = new IndexedFaceSet(cleanVertices, cvSize, 
+                               cleanNormals, cnSize,
+                               marray, meshMaterials.size(),
+                               0, 0,
+                               numFaces, numVertexPerFaces, faceStyle,
+                               cleanVIndices, viSize,
+                               cleanNIndices, niSize,
+                               MIndices, viSize,
+                               0,0,
+                               0);
+	  // sets the id of the rep
+	  rep->setId(Id(iNode->node_id, 0));
+
+
+      const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(minBBox[0], minBBox[1], minBBox[2]), 
+                                           Vec3r(maxBBox[0], maxBBox[1], maxBBox[2]));
+      rep->setBBox(bbox);
+      shape->AddRep(rep);
+    }
+
+    if (iNode->user.d) 
+    {
+      if(NULL != iNode->matrix)
+      {
+        Lib3dsObjectData *d = &iNode->data.object;
+        Matrix44r M44f;
+        for(unsigned i=0; i<4; i++)
+          for(unsigned j=0; j<4; j++)
+            M44f(i,j) = iNode->matrix[j][i];
+          
+          currentMesh->setMatrix(Matrix44r(M44f));
+          currentMesh->Translate(-d->pivot[0], -d->pivot[1], -d->pivot[2]);
+      }
+      shape = (NodeShape*)iNode->user.d;
+      currentMesh->AddChild(shape);
+      _Scene->AddChild(currentMesh);
+    }
+  }
+
+}
diff --git a/source/blender/freestyle/intern/scene_graph/MaxFileLoader.h b/source/blender/freestyle/intern/scene_graph/MaxFileLoader.h
new file mode 100755
index 00000000000..ce71ab4be3b
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/MaxFileLoader.h
@@ -0,0 +1,98 @@
+//
+//  Filename         : MaxFileLoader.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class used to load 3ds models.
+//  Date of creation : 10/10/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  MAX_FILE_LOADER_H
+# define MAX_FILE_LOADER_H
+
+# include <string.h>              
+# include <float.h>
+
+//soc - modified to adapt Blender's in
+// lib3ds includes
+# include <lib3ds/file.h>
+# include <lib3ds/node.h>
+# include <lib3ds/camera.h>
+# include <lib3ds/mesh.h>
+# include <lib3ds/material.h>
+# include <lib3ds/matrix.h>
+# include <lib3ds/vector.h>
+# include <lib3ds/file.h>
+
+# include "../system/FreestyleConfig.h"
+# include "NodeGroup.h"
+# include "NodeTransform.h"
+# include "NodeShape.h"
+# include "IndexedFaceSet.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+# include "../geometry/GeomCleaner.h"
+
+
+class NodeGroup;
+
+class LIB_SCENE_GRAPH_EXPORT MaxFileLoader
+{
+public:
+  /*! Builds a MaxFileLoader */
+  MaxFileLoader();
+  /*! Builds a MaxFileLoader to load the iFileName
+      file.
+        iFileName
+          The name of the 3dsMax file to load
+   */
+  explicit MaxFileLoader(const char *iFileName);
+  virtual ~MaxFileLoader();
+
+  /*! Sets the name of the 3dsMax file to load */
+  void setFileName(const char *iFileName);
+
+  /*! Loads the 3D scene and returns 
+   *  a pointer to the scene root node
+   */
+  NodeGroup * Load();
+  //void Load(const char *iFileName);
+
+  /*! Gets the number of read faces */
+  inline unsigned int numFacesRead() {return _numFacesRead;}
+
+  /*! Gets the smallest edge size read */
+  inline real minEdgeSize() {return _minEdgeSize;}
+
+protected:
+  void RenderNode(Lib3dsNode *iNode);
+
+protected:
+  char *_FileName;
+  Lib3dsFile *_3dsFile;
+  NodeGroup* _Scene;
+  unsigned _numFacesRead;
+  real _minEdgeSize;
+};
+
+#endif // MAX_FILE_LOADER_H
diff --git a/source/blender/freestyle/intern/scene_graph/Node.h b/source/blender/freestyle/intern/scene_graph/Node.h
new file mode 100755
index 00000000000..41afaa353be
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/Node.h
@@ -0,0 +1,97 @@
+//
+//  Filename         : Node.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Abstract class for scene graph nodes. Inherits from 
+//                     BaseObject which defines the addRef release mechanism.
+//  Date of creation : 24/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODE_H
+# define NODE_H
+
+# include "../system/FreestyleConfig.h"
+# include "../system/BaseObject.h"
+# include "SceneVisitor.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+# include "../system/Precision.h"
+
+using namespace std;
+using namespace Geometry;
+
+class LIB_SCENE_GRAPH_EXPORT Node : public BaseObject
+{
+public:
+
+  inline Node() : BaseObject() {}
+  inline Node(const Node& iBrother) : BaseObject()
+  {
+    _BBox = iBrother.bbox();
+  }
+  virtual ~Node(){}
+
+  /*! Accept the corresponding visitor
+   * Each inherited node 
+   * must overload this method
+   */
+  virtual void accept(SceneVisitor& v) {
+    v.visitNode(*this);
+  }
+
+  /*! bounding box management */
+  /*! Returns the node bounding box 
+   *  If no bounding box exists, an empty bbox
+   *  is returned
+   */
+  virtual const BBox<Vec3r>& bbox() const {return _BBox;}
+
+  /*! Sets the Node bounding box */
+  virtual void setBBox(const BBox<Vec3r>& iBox) {_BBox = iBox;}
+
+  /*! Makes the union of _BBox and iBox */
+  virtual void AddBBox(const BBox<Vec3r>& iBox) 
+  {
+    if(iBox.empty())
+      return;
+
+    if(_BBox.empty())
+      _BBox = iBox;
+    else
+      _BBox += iBox;
+  }
+
+  /*! Updates the BBox */
+  virtual const BBox<Vec3r>& UpdateBBox() {return _BBox;}
+
+  /*! Clears the bounding box */
+  virtual void clearBBox() { _BBox.clear(); }
+  
+protected:
+  
+private: 
+  BBox<Vec3r> _BBox;
+};
+
+#endif // NODE_H
diff --git a/source/blender/freestyle/intern/scene_graph/NodeCamera.cpp b/source/blender/freestyle/intern/scene_graph/NodeCamera.cpp
new file mode 100644
index 00000000000..2d850287ae5
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeCamera.cpp
@@ -0,0 +1,119 @@
+#include "NodeCamera.h"
+#include <math.h>
+
+void loadIdentity(double * matrix){
+    int i;
+
+    // Build Identity matrix
+    for(i=0;i<16;++i){
+        double value ;
+        if((i % 5) == 0)
+            value = 1.0;
+        else
+            value = 0;
+        matrix[i] = value;
+    }
+}
+
+NodeCamera::NodeCamera(CameraType camera_type)
+:camera_type_(camera_type){
+    loadIdentity(modelview_matrix_);
+    loadIdentity(projection_matrix_);
+}
+
+NodeCamera::NodeCamera(const NodeCamera& iBrother)
+:camera_type_(iBrother.camera_type_){
+    memcpy(modelview_matrix_, iBrother.modelview_matrix_, 16*sizeof(double));
+    memcpy(projection_matrix_, iBrother.projection_matrix_, 16*sizeof(double));
+}
+
+void NodeCamera::accept(SceneVisitor& v){
+    v.visitNodeCamera(*this)   ;
+}
+
+void NodeCamera::setModelViewMatrix(double modelview_matrix[16]){
+    memcpy(modelview_matrix_, modelview_matrix,16*sizeof(double));
+}
+
+void NodeCamera::setProjectionMatrix(double projection_matrix[16]){
+    memcpy(projection_matrix_, projection_matrix,16*sizeof(double));
+}
+
+NodeOrthographicCamera::NodeOrthographicCamera()
+:NodeCamera(NodeCamera::ORTHOGRAPHIC),
+left_(0),right_(0),bottom_(0),top_(0),zNear_(0),zFar_(0){
+    loadIdentity(projection_matrix_);
+    loadIdentity(modelview_matrix_);
+}
+
+NodeOrthographicCamera::NodeOrthographicCamera(double left
+                                                , double right
+                                                , double bottom
+                                                , double top
+                                                , double zNear
+                                                , double zFar
+                                                )
+:NodeCamera(NodeCamera::ORTHOGRAPHIC),
+left_(left),
+right_(right),
+bottom_(bottom),
+top_(top),
+zNear_(zNear),
+zFar_(zFar){
+
+    loadIdentity(projection_matrix_);
+
+    projection_matrix_[0] = 2.0/(right-left);
+    projection_matrix_[3] = -(right + left) / (right - left) ;
+    projection_matrix_[5] = 2.0/(top-bottom);
+    projection_matrix_[7] = -(top + bottom) / (top - bottom) ;
+    projection_matrix_[10] = -2.0/(zFar-zNear);
+    projection_matrix_[11] = -(zFar + zNear) / (zFar - zNear);
+
+}
+
+NodeOrthographicCamera::NodeOrthographicCamera(const NodeOrthographicCamera& iBrother)
+:NodeCamera(iBrother),left_(iBrother.left_),right_(iBrother.right_),bottom_(iBrother.bottom_),top_(iBrother.top_),zNear_(iBrother.zNear_),zFar_(iBrother.zFar_){
+}
+
+NodePerspectiveCamera::NodePerspectiveCamera()
+:NodeCamera(NodeCamera::PERSPECTIVE){
+}
+
+NodePerspectiveCamera::NodePerspectiveCamera(double fovy
+                                        , double aspect
+                                        , double zNear
+                                        , double zFar)
+:NodeCamera(NodeCamera::PERSPECTIVE){
+    loadIdentity(projection_matrix_);
+
+    double f = cos(fovy/2.0)/sin(fovy/2.0); // cotangent
+
+    projection_matrix_[0] = f/aspect;
+    projection_matrix_[5] = f;
+    projection_matrix_[10] = (zNear+zFar)/(zNear-zFar);
+    projection_matrix_[11] = (2.0*zNear*zFar)/(zNear-zFar);
+    projection_matrix_[14] = -1.0;
+    projection_matrix_[15] = 0;
+
+}
+
+NodePerspectiveCamera::NodePerspectiveCamera(double left,
+                                        double right,
+                                        double bottom,
+                                        double top,
+                                        double zNear,
+                                        double zFar)
+:NodeCamera(NodeCamera::PERSPECTIVE){
+    loadIdentity(projection_matrix_);
+
+    projection_matrix_[0] = (2.0*zNear)/(right-left);
+    projection_matrix_[2] = (right+left)/(right-left);
+    projection_matrix_[5] = (2.0*zNear)/(top-bottom);
+    projection_matrix_[6] = (top+bottom)/(top-bottom);
+    projection_matrix_[10] = - (zFar+zNear)/(zFar-zNear);
+    projection_matrix_[11] = - (2.0*zFar*zNear)/(zFar-zNear);
+    projection_matrix_[14] = -1.0;
+    projection_matrix_[15] = 0;
+}
+
diff --git a/source/blender/freestyle/intern/scene_graph/NodeCamera.h b/source/blender/freestyle/intern/scene_graph/NodeCamera.h
new file mode 100644
index 00000000000..76ccf465d38
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeCamera.h
@@ -0,0 +1,192 @@
+//
+//  Filename         : NodeCamera.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to represent a light node
+//  Date of creation : 25/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef NODE_CAMERA_H_
+#define NODE_CAMERA_H_
+
+# include "../geometry/Geom.h"
+# include "../system/FreestyleConfig.h"
+# include "Node.h"
+
+using namespace Geometry;
+
+class NodeOrthographicCamera;
+class NodePerspectiveCamera;
+class LIB_SCENE_GRAPH_EXPORT NodeCamera : public Node
+{
+public:
+    typedef enum {PERSPECTIVE,ORTHOGRAPHIC,GENERIC} CameraType;
+
+    /*! Default matrices: Identity for both projection and modelview. */
+    NodeCamera(CameraType camera_type = GENERIC); 
+    NodeCamera(const NodeCamera& iBrother);
+
+    virtual ~NodeCamera() {}
+
+    /*! Accept the corresponding visitor */
+    virtual void accept(SceneVisitor& v);
+
+    /*! Matrix is copied */
+    void setModelViewMatrix(double modelview_matrix[16]);
+    /*! Matrix is copied */
+    void setProjectionMatrix(double projection_matrix[16]);
+
+    double * modelViewMatrix() {return modelview_matrix_;}
+    double * projectionMatrix() {return projection_matrix_;}
+
+protected:
+    // row major right handed matrix
+    double modelview_matrix_[16];
+    // row major right handed matrix
+    double projection_matrix_[16];
+
+    CameraType camera_type_;
+};
+
+class LIB_SCENE_GRAPH_EXPORT NodeOrthographicCamera : public NodeCamera{
+public:
+    NodeOrthographicCamera();
+    /*! Builds a parallel projection matrix a la glOrtho.
+    A  	0  	0  	tx
+    0 	B 	0 	ty
+    0 	0 	C 	tz
+    0 	0 	0 	1
+
+    where
+
+    A =
+    2 / (right - left) 
+    B =
+    2 / (top - bottom) 
+    C =
+    -2 / (far - near) 
+    tx =
+    -(right + left) / (right - left) 
+    ty =
+    -(top + bottom) / (top - bottom) 
+    tz =
+    -(zFar + zNear) / (zFar - zNear) 
+    */
+    NodeOrthographicCamera(double left
+        , double right
+        , double bottom
+        , double top
+        , double zNear
+        , double zFar
+        );
+
+    double left() const {return left_;}
+    double right() const {return right_;}
+    double bottom() const {return bottom_;}
+    double top() const {return top_;}
+    double zNear() const {return zNear_;}
+    double zFar() const {return zFar_;}
+
+    NodeOrthographicCamera(const NodeOrthographicCamera& iBrother);
+
+private:
+    double left_;
+    double right_;
+    double bottom_;
+    double top_;
+    double zNear_;
+    double zFar_;
+};
+
+class LIB_SCENE_GRAPH_EXPORT NodePerspectiveCamera : public NodeCamera {
+public:
+    NodePerspectiveCamera();
+    /*! Builds a perspective projection matrix a la gluPerspective. 
+    Given	f defined as follows:
+    fovy
+    f	= cotangent(____)
+    2
+    The generated	matrix is
+
+
+    (	 f       		                                            )
+    |  ______				                                        |
+    |  aspect           0	            0		        0	        |
+    |					                                            |
+    |	0               f	            0		        0	        |
+    |					                                            |
+    |					            zNear+zFar       2*zNear*zFar   |
+    |		                        __________      ____________    |
+    |	0               0	        zNear-zFar       zNear-zFar     |
+    |					                                            |
+    (   0               0	            -1		        0           )
+    \param fovy
+    Field of View specified in radians.
+    */
+    NodePerspectiveCamera(double fovy
+        , double aspect
+        , double zNear
+        , double zFar);
+
+    /*! Builds a perspective projection matrix a la glFrustum.
+    (	2*zNear                                                         )
+    |  __________			                                            |
+    |  right-left           0               A               0           |
+    |                                                                   |
+    |			         2*zNear		                                |
+    |	  0	            __________          B               0           |
+    |		            top-bottom		                                |
+    |                                                                   |
+    |	  0	                0               C               D           |
+    |					                                                |
+    |	  0	                0               -1              0           |
+    (					                                                )
+
+    right+left
+    A = __________
+    right-left
+
+    top+bottom
+    B = __________
+    top-bottom
+
+    zFar+zNear
+    C = - __________
+    zFar-zNear
+
+    2*zFar*zNear
+    D = -  ____________
+    zFar-zNear
+    */
+    NodePerspectiveCamera(double left,
+        double right,
+        double bottom,
+        double top,
+        double zNear,
+        double zFar);
+};
+
+
+#endif // NODE_CAMERA_H_
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.cpp b/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.cpp
new file mode 100755
index 00000000000..acd740ee055
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.cpp
@@ -0,0 +1,34 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "NodeDrawingStyle.h"
+
+void NodeDrawingStyle::accept(SceneVisitor& v) {
+  v.visitNodeDrawingStyle(*this);
+
+  v.visitNodeDrawingStyleBefore(*this);
+  v.visitDrawingStyle(_DrawingStyle);
+  for(vector<Node*>::iterator node=_Children.begin(), end=_Children.end(); 
+  node!=end; 
+  node++)
+    (*node)->accept(v);
+  v.visitNodeDrawingStyleAfter(*this);
+}
diff --git a/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h b/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h
new file mode 100755
index 00000000000..012f963ea8c
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h
@@ -0,0 +1,70 @@
+//
+//  Filename         : NodeDrawingStyle.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a Drawing Style to be applied 
+//                     to the underlying children. Inherits from NodeGroup.
+//  Date of creation : 06/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODEDRAWINGSTYLE_H
+# define NODEDRAWINGSTYLE_H
+
+# include "../system/FreestyleConfig.h"
+# include "NodeGroup.h"
+# include "DrawingStyle.h"
+
+class LIB_SCENE_GRAPH_EXPORT NodeDrawingStyle : public NodeGroup
+{
+public:
+
+  inline NodeDrawingStyle() : NodeGroup() {}
+  virtual ~NodeDrawingStyle() {}
+
+  inline const DrawingStyle& drawingStyle() const { return _DrawingStyle; }
+  inline void setDrawingStyle(const DrawingStyle& iDrawingStyle) { _DrawingStyle = iDrawingStyle; }
+
+  /*! Sets the style. Must be one of FILLED, LINES, POINTS, INVISIBLE. */
+  inline void setStyle(const DrawingStyle::STYLE iStyle) { _DrawingStyle.setStyle(iStyle); }
+  /*! Sets the line width in the LINES style case */
+  inline void setLineWidth(const float iLineWidth) { _DrawingStyle.setLineWidth(iLineWidth); }
+  /*! Sets the Point size in the POINTS style case */
+  inline void setPointSize(const float iPointSize) { _DrawingStyle.setPointSize(iPointSize); }
+  /*! Enables or disables the lighting. TRUE = enable */
+  inline void setLightingEnabled(const bool iEnableLighting) { _DrawingStyle.setLightingEnabled(iEnableLighting); }
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! accessors */
+  inline DrawingStyle::STYLE style() const {return _DrawingStyle.style();}
+  inline float lineWidth() const {return _DrawingStyle.lineWidth();}
+  inline float pointSize() const {return _DrawingStyle.pointSize();}
+  inline bool lightingEnabled() const {return _DrawingStyle.lightingEnabled();}
+
+private:
+  DrawingStyle _DrawingStyle;
+};
+
+#endif // NODEDRAWINGSTYLE_H
diff --git a/source/blender/freestyle/intern/scene_graph/NodeGroup.cpp b/source/blender/freestyle/intern/scene_graph/NodeGroup.cpp
new file mode 100755
index 00000000000..3d2aa2c8694
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeGroup.cpp
@@ -0,0 +1,122 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "NodeGroup.h"
+
+void NodeGroup::AddChild(Node *iChild)
+{
+  if(NULL == iChild)
+    return;
+
+  _Children.push_back(iChild);
+  iChild->addRef();
+}
+
+int NodeGroup::destroy()
+{
+  /*! Node::destroy makes a release on the object 
+   *  and then returns the reference counter.
+   *  If the reference counter is equal to 0, 
+   *  that means that nobody else is linking 
+   *  this node group and that we can destroy the whole 
+   *  underlying tree.
+   *  Else, one or several Node link this node group, 
+   *  and we only returns the reference counter 
+   *  decremented by Node::destroy();
+   */
+  int refThis = Node::destroy();
+  
+  // if refThis != 0, we can't destroy the tree
+  if(0 != refThis) 
+    return refThis;
+
+  // If we are here, that means that nobody else
+  // needs our NodeGroup and we can destroy it.
+  int refCount = 0;
+  vector<Node *>::iterator node;
+  
+  for(node=_Children.begin(); node!=_Children.end(); node++)
+  {
+    refCount = (*node)->destroy();
+    if(0 == refCount)
+      delete (*node);
+  }
+
+  _Children.clear();
+  
+  return refThis;
+}
+
+void NodeGroup::accept(SceneVisitor& v) {
+  v.visitNodeGroup(*this);
+  
+  v.visitNodeGroupBefore(*this);
+  for(vector<Node *>::iterator node=_Children.begin(), end=_Children.end(); 
+  node!=end;
+  node++)
+    (*node)->accept(v);
+  v.visitNodeGroupAfter(*this);
+}
+
+void NodeGroup::DetachChildren()
+{
+  vector<Node *>::iterator node;
+  
+  for(node=_Children.begin(); node!=_Children.end(); node++)
+  {
+    (*node)->release();
+  }
+
+  _Children.clear();
+}
+
+void NodeGroup::DetachChild(Node *iChild)
+{
+  int found = 0;
+  vector<Node*>::iterator node;
+  
+  for(node=_Children.begin(); node!=_Children.end(); node++)
+  {
+    if((*node) == iChild)
+    {
+      (*node)->release();
+      _Children.erase(node);
+      found = 1;
+      break;
+    }
+  }
+}
+
+void NodeGroup::RetrieveChildren(vector<Node*>& oNodes){
+  oNodes = _Children;
+}
+
+const BBox<Vec3r>& NodeGroup::UpdateBBox()
+{
+  vector<Node *>::iterator node;
+  clearBBox();
+  for(node=_Children.begin(); node!=_Children.end(); node++)
+  {
+    AddBBox((*node)->UpdateBBox());
+  }
+
+  return Node::UpdateBBox();
+}
diff --git a/source/blender/freestyle/intern/scene_graph/NodeGroup.h b/source/blender/freestyle/intern/scene_graph/NodeGroup.h
new file mode 100755
index 00000000000..a1bd2b57e56
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeGroup.h
@@ -0,0 +1,84 @@
+//
+//  Filename         : NodeGroup.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to represent a group node. This node can contains
+//                     several children. It also contains a transform matrix
+//                     indicating the transform state of the underlying
+//                     children.
+//  Date of creation : 24/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODEGROUP_H
+# define NODEGROUP_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "Node.h"
+
+using namespace std;
+
+class LIB_SCENE_GRAPH_EXPORT NodeGroup : public Node
+{
+public:
+
+  inline NodeGroup(): Node() {}
+  virtual ~NodeGroup(){}
+
+  /*! Adds a child. Makes a addRef on the
+   *  iChild reference counter */
+  virtual void AddChild(Node *iChild);
+
+  /*! destroys all the underlying nodes 
+   *  Returns the reference counter 
+   *  after having done a release() */
+  virtual int destroy();
+
+  /*! Detaches all the children */
+  virtual void DetachChildren();
+
+  /*! Detached the sepcified child */
+  virtual void DetachChild(Node *iChild);
+
+  /*! Retrieve children */
+  virtual void RetrieveChildren(vector<Node*>& oNodes);
+
+
+  /*! Renders every children */
+  //  virtual void Render(Renderer *iRenderer);
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! Updates the BBox */
+  virtual const BBox<Vec3r>& UpdateBBox();
+
+  /*! Returns the number of children */
+  virtual int numberOfChildren() {return _Children.size();}
+
+protected:
+  vector<Node*> _Children;
+};
+
+#endif // NODEGROUP_H
diff --git a/source/blender/freestyle/intern/scene_graph/NodeLight.cpp b/source/blender/freestyle/intern/scene_graph/NodeLight.cpp
new file mode 100755
index 00000000000..61a46155cfa
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeLight.cpp
@@ -0,0 +1,80 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "NodeLight.h"
+
+int NodeLight::numberOfLights = 0;
+
+NodeLight::NodeLight()
+: Node() 
+{
+  if(numberOfLights > 7)
+  {
+    _number = 7;
+  }
+  else
+  {
+    _number = numberOfLights; 
+    numberOfLights++;
+  }
+  
+  Ambient[0] = Ambient[1] = Ambient[2] = 0.f;
+  Ambient[3] = 1.f;
+  
+  for(int i=0; i<4; i++)
+  {
+    Diffuse[i] = 1.f;
+    Specular[i] = 1.f;
+  }
+
+  Position[0] = Position[1] = Position[3] = 0.f;
+  Position[2] = 1.f;
+
+  on = true;
+}
+
+NodeLight::NodeLight(NodeLight& iBrother)
+: Node(iBrother)
+{
+    if(numberOfLights > 7)
+  {
+    _number = 7;
+  }
+  else
+  {
+    _number = numberOfLights; 
+    numberOfLights++;
+  }
+
+  for(int i=0; i<4; i++)
+  {
+    Ambient[i] = iBrother.ambient()[i];
+    Diffuse[i] = iBrother.diffuse()[i];
+    Specular[i] = iBrother.specular()[i];
+    Position[i] = iBrother.position()[i];
+  }
+
+  on = iBrother.isOn();
+}
+
+void NodeLight::accept(SceneVisitor& v) {
+  v.visitNodeLight(*this);
+}
diff --git a/source/blender/freestyle/intern/scene_graph/NodeLight.h b/source/blender/freestyle/intern/scene_graph/NodeLight.h
new file mode 100755
index 00000000000..0689505fb24
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeLight.h
@@ -0,0 +1,86 @@
+//
+//  Filename         : NodeLight.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to represent a light node
+//  Date of creation : 25/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODELIGHT_H
+# define NODELIGHT_H
+
+# include "../geometry/Geom.h"
+# include "../system/FreestyleConfig.h"
+# include "Node.h"
+
+using namespace Geometry;
+
+class LIB_SCENE_GRAPH_EXPORT NodeLight : public Node
+{
+public:
+
+  NodeLight(); 
+  NodeLight(NodeLight& iBrother);
+
+  virtual ~NodeLight() {}
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! Accessors for the light properties */
+  inline const float * ambient() const {return Ambient;}
+  inline const float * diffuse() const {return Diffuse;}
+  inline const float * specular() const {return Specular;}
+  inline const float * position() const {return Position;}
+  inline bool isOn() const {return on;}
+  inline int number() const {return _number;}
+ 
+private:
+  // Data members
+  // ============
+
+  /*! on=true, the light is on */
+  bool on;
+
+  /*! The color definition */
+  float Ambient[4];
+  float Diffuse[4];
+  float Specular[4];
+
+  /*! Light position. if w = 0, the light is 
+   * placed at infinite.
+   */
+  float Position[4];
+
+  /*! used to manage the number of lights */
+  /*! numberOfLights
+   *    the number of lights in the scene. 
+   *    Initially, 0.
+   */
+  static int numberOfLights;
+  /*! The current lignt number */
+  int _number;
+};
+
+#endif // NODELIGHT_H
diff --git a/source/blender/freestyle/intern/scene_graph/NodeShape.cpp b/source/blender/freestyle/intern/scene_graph/NodeShape.cpp
new file mode 100755
index 00000000000..2012ef83b9f
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeShape.cpp
@@ -0,0 +1,51 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "NodeShape.h"
+
+NodeShape::~NodeShape()
+{
+  vector<Rep *>::iterator rep;
+ 
+  if(0 != _Shapes.size())
+  {
+    for(rep=_Shapes.begin(); rep!=_Shapes.end(); rep++)
+    {
+      int refCount = (*rep)->destroy();
+      if(0 == refCount)
+        delete (*rep);
+    }
+
+    _Shapes.clear();
+  }
+}
+
+void NodeShape::accept(SceneVisitor& v) {
+  v.visitNodeShape(*this);
+  
+  v.visitMaterial(_Material);
+ 
+  v.visitNodeShapeBefore(*this);
+  vector<Rep *>::iterator rep;
+  for(rep = _Shapes.begin(); rep != _Shapes.end(); rep++)
+    (*rep)->accept(v);
+  v.visitNodeShapeAfter(*this);
+}
diff --git a/source/blender/freestyle/intern/scene_graph/NodeShape.h b/source/blender/freestyle/intern/scene_graph/NodeShape.h
new file mode 100755
index 00000000000..34b049bfeb5
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeShape.h
@@ -0,0 +1,89 @@
+//
+//  Filename         : NodeShape.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to build a shape node. It contains a Rep, 
+//                     which is the shape geometry
+//  Date of creation : 25/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODESHAPE_H
+# define NODESHAPE_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "Node.h"
+# include "Rep.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+# include "Material.h"
+
+using namespace std;
+using namespace Geometry;
+
+class LIB_SCENE_GRAPH_EXPORT NodeShape : public Node
+{
+public:
+  
+  inline NodeShape() : Node() {}
+  
+  virtual ~NodeShape();
+
+  /*! Adds a Rep to the _Shapes list
+   *  The delete of the rep is done 
+   *  when it is not used any more by 
+   *  the Scene Manager. So, it must not 
+   *  be deleted by the caller
+   */
+  virtual void AddRep(Rep *iRep)
+  {
+    if(NULL == iRep)
+      return;
+    _Shapes.push_back(iRep);
+    iRep->addRef();
+    
+    // updates bbox:
+    AddBBox(iRep->bbox());
+  }
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! Sets the shape material */
+  inline void setMaterial(const Material& iMaterial) { _Material = iMaterial; }
+
+  /*! accessors */
+  /*! returns the shape's material */
+  inline Material& material() { return _Material; }
+  inline const vector<Rep*>& shapes() {return _Shapes;}
+
+private:
+  /*! list of shapes */
+  vector<Rep*> _Shapes;
+
+  /*! Shape Material */
+  Material _Material;
+};
+
+#endif // NODESHAPE_H
diff --git a/source/blender/freestyle/intern/scene_graph/NodeTransform.cpp b/source/blender/freestyle/intern/scene_graph/NodeTransform.cpp
new file mode 100755
index 00000000000..8f706c78259
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeTransform.cpp
@@ -0,0 +1,166 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include "../system/FreestyleConfig.h"
+#include "NodeTransform.h"
+
+void NodeTransform::Translate(real x, real y, real z)
+{
+  _Matrix(0, 3) += x;
+  _Matrix(1, 3) += y;
+  _Matrix(2, 3) += z;
+}
+
+void NodeTransform::Rotate(real iAngle, real x, real y, real z)
+{
+  //Normalize the x,y,z vector;
+  real norm = (real)sqrt(x*x+y*y+z*z);
+  if(0 == norm)
+    return;
+
+  x /= norm;
+  y /= norm;
+  z /= norm;
+
+  // find the corresponding matrix with the Rodrigues formula:
+  // R = I + sin(iAngle)*Ntilda + (1-cos(iAngle))*Ntilda*Ntilda
+  Matrix33r Ntilda;
+  Ntilda(0,0) = Ntilda(1,1) = Ntilda(2,2) = 0.f;
+  Ntilda(0,1) = -z;
+  Ntilda(0,2) = y;
+  Ntilda(1,0) = z;
+  Ntilda(1,2) = -x;
+  Ntilda(2,0) = -y;
+  Ntilda(2,1) = x;
+
+  const Matrix33r Ntilda2(Ntilda * Ntilda);
+  
+
+  const real sinAngle = (real)sin((iAngle/180.f)*M_PI);
+  const real cosAngle = (real)cos((iAngle/180.f)*M_PI);
+  
+  Matrix33r NS(Ntilda*sinAngle);
+  Matrix33r NC(Ntilda2*(1.f-cosAngle));
+  Matrix33r R;
+  R = Matrix33r::identity();
+  R += NS + NC;
+  
+  //R4 is the corresponding 4x4 matrix
+  Matrix44r R4;
+  R4 = Matrix44r::identity();
+
+  for(int i=0; i<3; i++)
+    for(int j=0; j<3; j++)
+      R4(i,j) = R(i,j);
+    
+  // Finally, we multiply our current matrix by R4:
+  Matrix44r mat_tmp(_Matrix);
+  _Matrix = mat_tmp * R4;
+}
+
+void NodeTransform::Scale(real x, real y, real z)
+{
+  _Matrix(0,0) *= x;
+  _Matrix(1,1) *= y;
+  _Matrix(2,2) *= z;
+
+  _Scaled = true;
+}
+
+void NodeTransform::MultiplyMatrix(const Matrix44r &iMatrix)
+{
+  Matrix44r mat_tmp(_Matrix);
+  _Matrix = mat_tmp * iMatrix;
+}
+
+void NodeTransform::setMatrix(const Matrix44r &iMatrix)
+{
+  _Matrix = iMatrix;
+  if(isScaled(iMatrix))
+    _Scaled = true;
+}
+
+void NodeTransform::accept(SceneVisitor& v) {
+  v.visitNodeTransform(*this);
+
+  v.visitNodeTransformBefore(*this);
+  for(vector<Node *>::iterator node=_Children.begin(), end=_Children.end(); 
+  node!=end; 
+  node++)
+    (*node)->accept(v);
+  v.visitNodeTransformAfter(*this);
+}
+
+void NodeTransform::AddBBox(const BBox<Vec3r>& iBBox)
+{
+  Vec3r oldMin(iBBox.getMin());
+  Vec3r oldMax(iBBox.getMax());
+  
+  // compute the 8 corners of the bbox
+  HVec3r box[8];
+  box[0] = HVec3r(iBBox.getMin());
+  box[1] = HVec3r(oldMax[0], oldMin[1], oldMin[2]);
+  box[2] = HVec3r(oldMax[0], oldMax[1], oldMin[2]);
+  box[3] = HVec3r(oldMin[0], oldMax[1], oldMin[2]);
+  box[4] = HVec3r(oldMin[0], oldMin[1], oldMax[2]);
+  box[5] = HVec3r(oldMax[0], oldMin[1], oldMax[2]);
+  box[6] = HVec3r(oldMax[0], oldMax[1], oldMax[2]);
+  box[7] = HVec3r(oldMin[0], oldMax[1], oldMax[2]);
+
+  // Computes the transform iBBox
+  HVec3r tbox[8];
+  unsigned i;
+  for(i = 0; i < 8; i++)
+    tbox[i] = _Matrix * box[i];
+
+  Vec3r newMin(tbox[0]);
+  Vec3r newMax(tbox[0]);
+  for (i=0; i<8; i++)
+  {
+    for (unsigned int j=0; j<3; j++)
+    {
+      if (newMin[j] > tbox[i][j])
+        newMin[j] = tbox[i][j];
+      if (newMax[j] < tbox[i][j])
+        newMax[j] = tbox[i][j];
+    }
+  }
+  
+  BBox<Vec3r> transformBox(newMin, newMax);
+  
+  Node::AddBBox(transformBox);
+}
+
+bool NodeTransform::isScaled(const Matrix44r &M)
+{
+  for(unsigned int j=0; j<3; j++)
+  {
+    real norm = 0;
+    for(unsigned int i=0; i<3; i++)
+    {
+      norm += M(i,j)*M(i,j);
+    }
+    if((norm > 1.01) || (norm < 0.99))
+      return true;
+  }
+
+  return false;
+}
diff --git a/source/blender/freestyle/intern/scene_graph/NodeTransform.h b/source/blender/freestyle/intern/scene_graph/NodeTransform.h
new file mode 100755
index 00000000000..e75132466f0
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/NodeTransform.h
@@ -0,0 +1,107 @@
+//
+//  Filename         : NodeTransform.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to represent a transform node. A Transform node 
+//                     contains one or several children, all affected by the 
+//                     transformation.
+//  Date of creation : 06/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NODETRANSFORM_H
+# define NODETRANSFORM_H
+
+# include "../geometry/Geom.h"
+# include "../system/FreestyleConfig.h"
+# include "NodeGroup.h"
+
+using namespace Geometry;
+
+class LIB_SCENE_GRAPH_EXPORT NodeTransform : public NodeGroup
+{
+public:
+  
+  inline NodeTransform() : NodeGroup() {
+    _Matrix = Matrix44r::identity();
+    _Scaled=false;
+  }
+
+  virtual ~NodeTransform() {}
+
+  /*! multiplys the current matrix by the 
+   * x, y, z translation matrix.
+   */
+  void Translate(real x, real y, real z);
+
+  /*! multiplys the current matrix by a 
+   *  rotation matrix
+   *    iAngle
+   *      The rotation angle
+   *    x, y, z
+   *      The rotation axis
+   */
+  void Rotate(real iAngle, real x, real y, real z);
+
+  /*! multiplys the current matrix by a 
+   *  scaling matrix.
+   *    x, y, z
+   *      The scaling coefficients
+   *      with respect to the x,y,z axis
+   */
+  void Scale(real x, real y, real z);
+
+  /*! Multiplys the current matrix
+   *  by iMatrix
+   */
+  void MultiplyMatrix(const Matrix44r &iMatrix);
+
+  /*! Sets the current matrix to iMatrix */
+  void setMatrix(const Matrix44r &iMatrix);
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+
+  /*! Overloads the Node::AddBBox in order to take care 
+   *  about the transformation
+   */
+  virtual void AddBBox(const BBox<Vec3r>& iBBox);
+
+  /*! Checks whether a matrix contains a scale factor 
+   *  or not.
+   *  Returns true if yes.
+   *    iMatrix
+   *      The matrix to check
+   */
+  bool isScaled(const Matrix44r &M);
+
+  /*! accessors */
+  inline const Matrix44r& matrix() const { return _Matrix; }
+  inline bool scaled() const {return _Scaled;}
+
+private:
+  Matrix44r _Matrix;
+  bool _Scaled;
+};
+
+#endif // NODETRANSFORM_H
diff --git a/source/blender/freestyle/intern/scene_graph/OrientedLineRep.cpp b/source/blender/freestyle/intern/scene_graph/OrientedLineRep.cpp
new file mode 100755
index 00000000000..2d0205308b9
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/OrientedLineRep.cpp
@@ -0,0 +1,31 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "OrientedLineRep.h"
+#include "../system/BaseObject.h"
+
+void OrientedLineRep::accept(SceneVisitor& v) {
+  Rep::accept(v);
+  if(!material())
+    v.visitOrientedLineRep(*this);
+  else
+    v.visitLineRep(*this);
+}
diff --git a/source/blender/freestyle/intern/scene_graph/OrientedLineRep.h b/source/blender/freestyle/intern/scene_graph/OrientedLineRep.h
new file mode 100755
index 00000000000..4274581e39a
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/OrientedLineRep.h
@@ -0,0 +1,67 @@
+//
+//  Filename         : OrientedLineRep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to display an oriented line representation.
+//  Date of creation : 24/10/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWEDGEREP_H
+# define VIEWEDGEREP_H
+
+# include "../system/FreestyleConfig.h"
+# include "LineRep.h"
+
+class LIB_SCENE_GRAPH_EXPORT OrientedLineRep : public LineRep
+{
+public:
+
+  OrientedLineRep() : LineRep() {}
+  /*! Builds a single line from 2 vertices
+   *  v1
+   *    first vertex
+   *  v2
+   *    second vertex
+   */
+  inline OrientedLineRep(const Vec3r& v1, const Vec3r& v2)
+    : LineRep(v1,v2)
+  {}
+
+  /*! Builds a line rep from a vertex chain */
+  inline OrientedLineRep(const vector<Vec3r>& vertices)
+    : LineRep(vertices)
+  {}
+
+  /*! Builds a line rep from a vertex chain */
+  inline OrientedLineRep(const list<Vec3r>& vertices)
+    : LineRep(vertices)
+  {}
+
+  virtual ~OrientedLineRep() {}
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v);
+};
+
+#endif // VIEWEDGEREP_H
diff --git a/source/blender/freestyle/intern/scene_graph/Rep.cpp b/source/blender/freestyle/intern/scene_graph/Rep.cpp
new file mode 100755
index 00000000000..520d3c41e2e
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/Rep.cpp
@@ -0,0 +1 @@
+#include "Rep.h"
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/scene_graph/Rep.h b/source/blender/freestyle/intern/scene_graph/Rep.h
new file mode 100755
index 00000000000..ee5f2942abf
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/Rep.h
@@ -0,0 +1,127 @@
+//
+//  Filename         : Rep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Base class for all shapes. Inherits from BasicObjects 
+//                     for references counter management (addRef, release).
+//  Date of creation : 25/01/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  REP_H
+# define REP_H
+
+# include "../system/BaseObject.h"
+# include "SceneVisitor.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+# include "../system/Precision.h"
+# include "Material.h"
+# include "../system/Id.h"
+
+using namespace Geometry;
+
+class LIB_SCENE_GRAPH_EXPORT Rep : public BaseObject
+{
+public:
+  
+  inline Rep() : BaseObject() {_Id = 0; _Material=0;}
+  inline Rep(const Rep& iBrother)
+    : BaseObject()
+  {
+    _Id = iBrother._Id;
+    if(0 == iBrother._Material)
+      _Material = 0;
+    else
+      _Material = new Material(*(iBrother._Material));
+
+    _BBox = iBrother.bbox();
+  }
+	inline void swap(Rep& ioOther){
+		std::swap(_BBox,ioOther._BBox);
+		std::swap(_Id, ioOther._Id);
+		std::swap(_Material,ioOther._Material);
+	}
+	Rep& operator=(const Rep& iBrother){
+		if(&iBrother != this){
+			_Id = iBrother._Id;
+			if(0 == iBrother._Material)
+				_Material = 0;
+			else{
+				if(_Material == 0){
+					_Material = new Material(*iBrother._Material);
+				}else{
+					(*_Material)=(*(iBrother._Material));
+				}
+				_BBox = iBrother.bbox();
+			}
+		}
+		return *this;
+	}
+  virtual ~Rep() 
+  {
+    if(0 != _Material)
+    {
+      delete _Material;
+      _Material = 0;
+    }
+  }
+
+  /*! Accept the corresponding visitor
+   *  Must be overload by 
+   *  inherited classes
+   */
+  virtual void accept(SceneVisitor& v) {
+    if(_Material)
+      v.visitMaterial(*_Material);
+    v.visitRep(*this);
+  }
+
+  /*! Computes the rep bounding box.
+   *  Each Inherited rep must compute 
+   *  its bbox depending on the way the data
+   *  are stored. So, each inherited class 
+   *  must overload this method
+   */
+  virtual void ComputeBBox() = 0;
+  
+  /*! Returns the rep bounding box */
+  virtual const BBox<Vec3r>& bbox() const {return _BBox;}
+  inline Id getId() const {return _Id;}
+  inline const Material * material() const {return _Material;}
+
+  /*! Sets the Rep bounding box */
+  virtual void setBBox(const BBox<Vec3r>& iBox) {_BBox = iBox;}
+  inline void setId(const Id& id) {_Id = id;}
+  inline void setMaterial(const Material& iMaterial) 
+  {
+    _Material = new Material(iMaterial);
+  }
+
+private:
+  BBox<Vec3r> _BBox;
+  Id _Id;
+  Material *_Material;
+};
+
+#endif // REP_H
diff --git a/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.cpp b/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.cpp
new file mode 100755
index 00000000000..aeee87f8222
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.cpp
@@ -0,0 +1,86 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iomanip>
+#include "ScenePrettyPrinter.h"
+#include "IndexedFaceSet.h"
+
+#define VISIT(CLASS) \
+  void ScenePrettyPrinter::visit##CLASS(CLASS&) { \
+    _ofs << _space << #CLASS << endl; \
+  }
+
+VISIT(Node)
+VISIT(NodeShape)
+VISIT(NodeGroup)
+VISIT(NodeLight)
+VISIT(NodeDrawingStyle)
+VISIT(NodeTransform)
+
+void ScenePrettyPrinter::visitNodeShapeBefore(NodeShape&) {
+  increaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeShapeAfter(NodeShape&) {
+  decreaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeGroupBefore(NodeGroup&) {
+  increaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeGroupAfter(NodeGroup&) {
+  decreaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeDrawingStyleBefore(NodeDrawingStyle&) {
+  increaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeDrawingStyleAfter(NodeDrawingStyle&) {
+  decreaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeTransformBefore(NodeTransform&) {
+  increaseSpace();
+}
+
+void ScenePrettyPrinter::visitNodeTransformAfter(NodeTransform&) {
+  decreaseSpace();
+}
+
+VISIT(LineRep)
+VISIT(OrientedLineRep)
+VISIT(TriangleRep)
+VISIT(VertexRep)
+
+void ScenePrettyPrinter::visitIndexedFaceSet(IndexedFaceSet& ifs) {
+  const real*	vertices = ifs.vertices();
+  unsigned	vsize = ifs.vsize();
+
+  _ofs << _space << "IndexedFaceSet" << endl;
+  const real *p = vertices;
+  for (unsigned i = 0; i < vsize / 3; i++) {
+    _ofs << _space << "  " << setw(3) << setfill('0') << i << ": "
+	 << p[0] << ", " << p[1] << ", " << p[2] << endl;
+    p += 3;
+  }
+}
diff --git a/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.h b/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.h
new file mode 100755
index 00000000000..4e83825ff55
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.h
@@ -0,0 +1,105 @@
+//
+//  Filename         : ScenePrettyPrinter.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class to display textual information
+//                     about a scene graph.
+//  Date of creation : 26/04/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SCENE_PRETTY_PRINTER_H
+# define SCENE_PRETTY_PRINTER_H
+
+# include <iostream>
+# include <fstream>
+# include <string>
+# include "SceneVisitor.h"
+
+using namespace std;
+
+class ScenePrettyPrinter : public SceneVisitor
+{
+public:
+
+  ScenePrettyPrinter(const string filename = "SceneLog.txt")
+    : SceneVisitor() {
+    if (!filename.empty())
+      _ofs.open(filename.c_str());
+    if (!_ofs.is_open())
+      cerr << "Warning, unable to open file \"" << filename << "\"" << endl;
+    _space = "";
+  }
+
+  virtual ~ScenePrettyPrinter() {
+    if (_ofs.is_open())
+      _ofs.close();
+  }
+
+
+  //
+  // visitClass methods
+  //
+  //////////////////////////////////////////////
+
+  VISIT_DECL(Node)
+  VISIT_DECL(NodeShape)
+  VISIT_DECL(NodeGroup)
+  VISIT_DECL(NodeLight)
+  VISIT_DECL(NodeDrawingStyle)
+  VISIT_DECL(NodeTransform)
+
+  VISIT_DECL(LineRep)
+  VISIT_DECL(OrientedLineRep)
+  VISIT_DECL(TriangleRep)
+  VISIT_DECL(VertexRep)
+  VISIT_DECL(IndexedFaceSet)
+
+  virtual void visitNodeShapeBefore(NodeShape&);
+  virtual void visitNodeShapeAfter(NodeShape&);
+  virtual void visitNodeGroupBefore(NodeGroup&);
+  virtual void visitNodeGroupAfter(NodeGroup&);
+  virtual void visitNodeDrawingStyleBefore(NodeDrawingStyle&);
+  virtual void visitNodeDrawingStyleAfter(NodeDrawingStyle&);
+  virtual void visitNodeTransformBefore(NodeTransform&);
+  virtual void visitNodeTransformAfter(NodeTransform&);
+
+ protected:
+  
+  void increaseSpace()
+  {
+    _space += "  ";
+  }
+
+  void decreaseSpace()
+  {
+    _space.erase(0, 2);
+  }
+
+ private:
+
+  ofstream	_ofs;
+  string	_space;
+};
+
+#endif // SCENE_PRETTY_PRINTER_H
diff --git a/source/blender/freestyle/intern/scene_graph/SceneVisitor.cpp b/source/blender/freestyle/intern/scene_graph/SceneVisitor.cpp
new file mode 100755
index 00000000000..9cfb9d40d24
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/SceneVisitor.cpp
@@ -0,0 +1 @@
+#include "SceneVisitor.h"
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/scene_graph/SceneVisitor.h b/source/blender/freestyle/intern/scene_graph/SceneVisitor.h
new file mode 100755
index 00000000000..c57bd2e0f6e
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/SceneVisitor.h
@@ -0,0 +1,98 @@
+//
+//  Filename         : SceneVisitor.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Class to visit (without doing anything)
+//                     a scene graph structure
+//  Date of creation : 26/04/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SCENE_VISITOR_H
+# define SCENE_VISITOR_H
+
+# define VISIT_COMPLETE_DEF(type)		\
+virtual void visit##type(type&) {}		\
+virtual void visit##type##Before(type&) {}	\
+virtual void visit##type##After(type&) {}
+
+# define VISIT_DECL(type) virtual void visit##type(type&);
+
+# define VISIT_COMPLETE_DECL(type) \
+    virtual void visit##type##Before(type&); \
+    virtual void visit##type(type&); \
+    virtual void visit##type##After(type&); 
+
+#include "../system/FreestyleConfig.h"
+
+class Node;
+class NodeShape;
+class NodeGroup;
+class NodeLight;
+class NodeCamera;
+class NodeDrawingStyle;
+class NodeTransform;
+
+class Rep;
+class LineRep;
+class OrientedLineRep;
+class TriangleRep;
+class VertexRep;
+class IndexedFaceSet;
+class DrawingStyle;
+class Material;
+
+class LIB_SCENE_GRAPH_EXPORT SceneVisitor
+{
+public:
+  
+  SceneVisitor() {}
+  virtual ~SceneVisitor() {}
+
+  virtual void beginScene() {}
+  virtual void endScene() {}
+
+  //
+  // visitClass methods
+  //
+  //////////////////////////////////////////////
+
+  VISIT_COMPLETE_DEF(Node)
+  VISIT_COMPLETE_DEF(NodeShape)
+  VISIT_COMPLETE_DEF(NodeGroup)
+  VISIT_COMPLETE_DEF(NodeLight)
+  VISIT_COMPLETE_DEF(NodeCamera)
+  VISIT_COMPLETE_DEF(NodeDrawingStyle)
+  VISIT_COMPLETE_DEF(NodeTransform)
+
+  VISIT_COMPLETE_DEF(Rep)
+  VISIT_COMPLETE_DEF(LineRep)
+  VISIT_COMPLETE_DEF(OrientedLineRep)
+  VISIT_COMPLETE_DEF(TriangleRep)
+  VISIT_COMPLETE_DEF(VertexRep)
+  VISIT_COMPLETE_DEF(IndexedFaceSet)
+  VISIT_COMPLETE_DEF(DrawingStyle)
+  VISIT_COMPLETE_DEF(Material)
+};
+
+#endif // SCENEVISITOR_H
diff --git a/source/blender/freestyle/intern/scene_graph/TriangleRep.cpp b/source/blender/freestyle/intern/scene_graph/TriangleRep.cpp
new file mode 100755
index 00000000000..f73a8498714
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/TriangleRep.cpp
@@ -0,0 +1,59 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "TriangleRep.h"
+
+void TriangleRep::ComputeBBox()
+{
+  real XMax = _vertices[0][0];
+  real YMax = _vertices[0][1];
+  real ZMax = _vertices[0][2];
+
+  real XMin = _vertices[0][0];
+  real YMin = _vertices[0][1];
+  real ZMin = _vertices[0][2];
+
+  // parse all the coordinates to find 
+  // the XMax, YMax, ZMax
+  for(int i=0; i<3; ++i)
+  {
+    // X
+    if(_vertices[i][0] > XMax)
+      XMax = _vertices[i][0];
+    if(_vertices[i][0] < XMin)
+      XMin = _vertices[i][0];
+
+    // Y
+    if(_vertices[i][1] > YMax)
+      YMax = _vertices[i][1];
+    if(_vertices[i][1] < YMin)
+      YMin = _vertices[i][1];
+
+    // Z
+    if(_vertices[i][2] > ZMax)
+      ZMax = _vertices[i][2];
+    if(_vertices[i][2] < ZMin)
+      ZMin = _vertices[i][2];
+
+  }
+
+  setBBox(BBox<Vec3r>(Vec3r(XMin, YMin, ZMin), Vec3r(XMax, YMax, ZMax)));
+}
diff --git a/source/blender/freestyle/intern/scene_graph/TriangleRep.h b/source/blender/freestyle/intern/scene_graph/TriangleRep.h
new file mode 100755
index 00000000000..9d986857060
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/TriangleRep.h
@@ -0,0 +1,106 @@
+//
+//  Filename         : TriangleRep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the represenation of a triangle
+//  Date of creation : 16/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  TRIANGLEREP_H
+# define TRIANGLEREP_H
+
+//! inherits from class Rep 
+#include "Rep.h"
+
+/*! Base class for all lines objects */
+class LIB_SCENE_GRAPH_EXPORT TriangleRep : public Rep
+{
+public:
+  
+  /*! Line description style */
+  enum TRIANGLE_STYLE{FILL, LINES};
+private:
+  TRIANGLE_STYLE _Style;
+  Vec3r _vertices[3];
+  Vec3r _colors[3];
+public:
+  inline TriangleRep() : Rep() {_Style = FILL;}
+
+  /*! Builds a triangle from 3 vertices
+   *  v0
+   *    first vertex
+   *  v1
+   *    second vertex
+   *  v2
+   *    third vertex
+   */
+  inline TriangleRep(const Vec3r& v0, const Vec3r& v1, const Vec3r& v2)
+    : Rep()
+  {
+    _vertices[0] = v0;
+    _vertices[1] = v1;
+    _vertices[2] = v2;
+    _Style = FILL;
+  }
+  inline TriangleRep( const Vec3r& v0, const Vec3r& c0,
+                      const Vec3r& v1, const Vec3r& c1,
+                      const Vec3r& v2, const Vec3r& c2)
+    : Rep()
+  {
+    _vertices[0] = v0;
+    _vertices[1] = v1;
+    _vertices[2] = v2;
+    _colors[0] = c0;
+    _colors[1] = c1;
+    _colors[2] = c2;
+    _Style = FILL;
+  }
+
+  virtual ~TriangleRep() 
+  {} 
+
+  /*! accessors */
+  inline const TRIANGLE_STYLE style() const {return _Style;}
+  inline const Vec3r& vertex(int index) const {return _vertices[index];}
+  inline const Vec3r& color(int index) const {return _colors[index];}
+  /*! modifiers */
+  inline void setStyle(const TRIANGLE_STYLE iStyle) {_Style = iStyle;}
+  inline void setVertex(int index, const Vec3r& iVertex) {_vertices[index] = iVertex;}
+  inline void setColor(int index, const Vec3r& iColor) {_colors[index] = iColor;}
+  inline void setVertices(const Vec3r& v0, const Vec3r& v1, const Vec3r& v2) {_vertices[0] = v0; _vertices[1] = v1; _vertices[2] = v2;}
+  inline void setColors(const Vec3r& c0, const Vec3r& c1, const Vec3r& c2) {_colors[0] = c0; _colors[1] = c1; _colors[2] = c2;}
+
+  /*! Accept the corresponding visitor */
+  virtual void accept(SceneVisitor& v) {
+    Rep::accept(v);
+    v.visitTriangleRep(*this);
+  }
+
+  /*! Computes the triangle bounding box.*/
+  virtual void ComputeBBox();
+
+
+};
+
+#endif
diff --git a/source/blender/freestyle/intern/scene_graph/VertexRep.cpp b/source/blender/freestyle/intern/scene_graph/VertexRep.cpp
new file mode 100755
index 00000000000..e4f774bfb84
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/VertexRep.cpp
@@ -0,0 +1,29 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "VertexRep.h"
+
+void VertexRep::ComputeBBox()
+{
+
+  setBBox(BBox<Vec3r>(Vec3r(_coordinates[0], _coordinates[1], _coordinates[2]), 
+                      Vec3r(_coordinates[0], _coordinates[1], _coordinates[2])));
+}
diff --git a/source/blender/freestyle/intern/scene_graph/VertexRep.h b/source/blender/freestyle/intern/scene_graph/VertexRep.h
new file mode 100755
index 00000000000..9e31b4b8ef9
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/VertexRep.h
@@ -0,0 +1,87 @@
+//
+//  Filename         : VertexRep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the representation of a vertex for
+//                     displaying purpose.
+//  Date of creation : 03/04/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VERTEXREP_H
+# define VERTEXREP_H
+
+#include "Rep.h"
+
+class LIB_SCENE_GRAPH_EXPORT VertexRep : public Rep
+{
+public:
+  
+  inline VertexRep() : Rep() {_vid = 0;_PointSize = 0.f;}
+  inline VertexRep(real x, real y, real z, int id = 0) 
+    : Rep()
+  {
+    _coordinates[0] = x;
+    _coordinates[1] = y;
+    _coordinates[2] = z;
+
+    _vid = id;
+    _PointSize = 0.f;
+  }
+
+  inline ~VertexRep() {}
+
+  /*! Accept the corresponding visitor */
+
+  virtual void accept(SceneVisitor& v) {
+    Rep::accept(v);
+    v.visitVertexRep(*this);
+  }
+
+  /*! Computes the rep bounding box.
+   */
+  virtual void ComputeBBox();
+
+  /*! accessors */
+  inline const int vid() const {return _vid;}
+  inline const real * coordinates() const {return _coordinates;}
+  inline real x() const {return _coordinates[0];}
+  inline real y() const {return _coordinates[1];}
+  inline real z() const {return _coordinates[2];}
+  inline float pointSize() const {return _PointSize;}
+
+  /*! modifiers */
+  inline void setVid(int id) {_vid = id;}
+  inline void setX(real x) {_coordinates[0] = x;}
+  inline void setY(real y) {_coordinates[1] = y;}
+  inline void setZ(real z) {_coordinates[2] = z;}
+  inline void setCoordinates(real x, real y, real z) {_coordinates[0] = x;_coordinates[1] = y; _coordinates[2] = z;}
+  inline void setPointSize(float iPointSize) {_PointSize = iPointSize;}
+
+private:
+  int _vid; // vertex id
+  real _coordinates[3];
+  float _PointSize;
+};
+
+#endif // VERTEXREP_H
diff --git a/source/blender/freestyle/intern/scene_graph/scene_graph.pro b/source/blender/freestyle/intern/scene_graph/scene_graph.pro
new file mode 100755
index 00000000000..5736104a597
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/scene_graph.pro
@@ -0,0 +1,86 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_SCENE_GRAPH}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll 3ds$${LIB3DS_VERSION_MAJ}.$${LIB3DS_VERSION_MIN}
+
+
+exists (../libconfig.pri) {
+  include (../libconfig.pri)
+}
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES *= MAKE_LIB_SCENE_GRAPH_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../geometry ../system
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# LIBS
+#
+#######################################
+
+win32:LIBS      *= $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+		   $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib
+!win32 {
+  lib_bundle {
+    LIBS += -F$${DESTDIR} -framework $${LIB_GEOMETRY} \
+	    -framework $${LIB_SYSTEM}
+  } else {
+    LIBS *= -L$${DESTDIR}/ -l$${LIB_GEOMETRY} -l$${LIB_SYSTEM}
+  }
+}
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/intern/scene_graph/src.pri b/source/blender/freestyle/intern/scene_graph/src.pri
new file mode 100755
index 00000000000..994db200812
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/src.pri
@@ -0,0 +1,41 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+SCENE_GRAPH_DIR = ../scene_graph
+
+SOURCES *= $${SCENE_GRAPH_DIR}/IndexedFaceSet.cpp \
+           $${SCENE_GRAPH_DIR}/LineRep.cpp \
+           $${SCENE_GRAPH_DIR}/MaxFileLoader.cpp \
+           $${SCENE_GRAPH_DIR}/NodeCamera.cpp \
+           $${SCENE_GRAPH_DIR}/NodeDrawingStyle.cpp \
+           $${SCENE_GRAPH_DIR}/NodeGroup.cpp \
+           $${SCENE_GRAPH_DIR}/NodeLight.cpp \
+           $${SCENE_GRAPH_DIR}/NodeShape.cpp \
+           $${SCENE_GRAPH_DIR}/NodeTransform.cpp \
+           $${SCENE_GRAPH_DIR}/OrientedLineRep.cpp \
+           $${SCENE_GRAPH_DIR}/ScenePrettyPrinter.cpp \
+           $${SCENE_GRAPH_DIR}/TriangleRep.cpp \
+           $${SCENE_GRAPH_DIR}/VertexRep.cpp \
+           $${SCENE_GRAPH_DIR}/Rep.cpp \
+           $${SCENE_GRAPH_DIR}/SceneVisitor.cpp
+
+HEADERS *= $${SCENE_GRAPH_DIR}/DrawingStyle.h \
+           $${SCENE_GRAPH_DIR}/IndexedFaceSet.h \
+           $${SCENE_GRAPH_DIR}/LineRep.h \
+           $${SCENE_GRAPH_DIR}/Material.h \
+           $${SCENE_GRAPH_DIR}/MaxFileLoader.h \
+           $${SCENE_GRAPH_DIR}/Node.h \
+           $${SCENE_GRAPH_DIR}/NodeCamera.h \
+           $${SCENE_GRAPH_DIR}/NodeDrawingStyle.h \
+           $${SCENE_GRAPH_DIR}/NodeGroup.h \
+           $${SCENE_GRAPH_DIR}/NodeLight.h \
+           $${SCENE_GRAPH_DIR}/NodeShape.h \
+           $${SCENE_GRAPH_DIR}/NodeTransform.h \
+           $${SCENE_GRAPH_DIR}/OrientedLineRep.h \
+           $${SCENE_GRAPH_DIR}/Rep.h \
+           $${SCENE_GRAPH_DIR}/ScenePrettyPrinter.h \
+           $${SCENE_GRAPH_DIR}/SceneVisitor.h \
+           $${SCENE_GRAPH_DIR}/TriangleRep.h \
+           $${SCENE_GRAPH_DIR}/VertexRep.h
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.cpp b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.cpp
new file mode 100755
index 00000000000..c22e183eccb
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.cpp
@@ -0,0 +1,85 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "../view_map/Functions0D.h"
+# include "AdvancedFunctions0D.h"
+# include "../view_map/SteerableViewMap.h"
+# include "Canvas.h"
+
+namespace Functions0D {
+
+  double DensityF0D::operator()(Interface0DIterator& iter) {
+    Canvas* canvas = Canvas::getInstance();
+    int bound = _filter.getBound();
+    if( (iter->getProjectedX()-bound < 0) || (iter->getProjectedX()+bound>canvas->width())
+	|| (iter->getProjectedY()-bound < 0) || (iter->getProjectedY()+bound>canvas->height()))
+      return 0.0;
+    RGBImage image;
+    canvas->readColorPixels((int)iter->getProjectedX() - bound,
+			    (int)iter->getProjectedY() - bound,
+			    _filter.maskSize(),
+			    _filter.maskSize(),
+			    image);
+    return _filter.getSmoothedPixel<RGBImage>(&image, (int)iter->getProjectedX(),
+					(int)iter->getProjectedY());
+  }
+
+
+  double LocalAverageDepthF0D::operator()(Interface0DIterator& iter) {
+    Canvas * iViewer = Canvas::getInstance();
+    int bound = _filter.getBound();
+    
+    if( (iter->getProjectedX()-bound < 0) || (iter->getProjectedX()+bound>iViewer->width())
+	|| (iter->getProjectedY()-bound < 0) || (iter->getProjectedY()+bound>iViewer->height()))
+      return 0.0;
+    GrayImage image ;
+    iViewer->readDepthPixels((int)iter->getProjectedX()-bound,(int)iter->getProjectedY()-bound,_filter.maskSize(),_filter.maskSize(),image);
+    return _filter.getSmoothedPixel(&image, (int)iter->getProjectedX(), (int)iter->getProjectedY());
+  }
+
+  float ReadMapPixelF0D::operator()(Interface0DIterator& iter) {
+    Canvas * canvas = Canvas::getInstance();
+    return canvas->readMapPixel(_mapName, _level, (int)iter->getProjectedX(), (int)iter->getProjectedY());
+  }
+
+  float ReadSteerableViewMapPixelF0D::operator()(Interface0DIterator& iter) {
+    SteerableViewMap *svm = Canvas::getInstance()->getSteerableViewMap();
+    float v = svm->readSteerableViewMapPixel(_orientation, _level,(int)iter->getProjectedX(), (int)iter->getProjectedY());
+    return v;
+  }
+
+  float ReadCompleteViewMapPixelF0D::operator()(Interface0DIterator& iter) {
+    SteerableViewMap *svm = Canvas::getInstance()->getSteerableViewMap();
+    float v = svm->readCompleteViewMapPixel(_level,(int)iter->getProjectedX(), (int)iter->getProjectedY());
+    return v;
+  }
+
+  float GetViewMapGradientNormF0D::operator()(Interface0DIterator& iter){
+    SteerableViewMap *svm = Canvas::getInstance()->getSteerableViewMap();
+    float pxy = svm->readCompleteViewMapPixel(_level,(int)iter->getProjectedX(), (int)iter->getProjectedY());
+    float gx = svm->readCompleteViewMapPixel(_level,(int)iter->getProjectedX()+_step, (int)iter->getProjectedY())
+      - pxy;
+    float gy = svm->readCompleteViewMapPixel(_level,(int)iter->getProjectedX(), (int)iter->getProjectedY()+_step)
+      - pxy;
+	float f = Vec2f(gx,gy).norm();
+    return f;
+  }
+} // end of namespace Functions0D
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
new file mode 100755
index 00000000000..9eee6714b09
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h
@@ -0,0 +1,209 @@
+//
+//  Filename         : AdvancedFunctions0D.h
+//  Author(s)        : Stephane Grabli
+//                     Emmanuel Turquin
+//  Purpose          : Functions taking 0D input
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ADVANCED_FUNCTIONS0D_HPP
+# define ADVANCED_FUNCTIONS0D_HPP
+
+
+# include "../image/Image.h"
+# include "../image/GaussianFilter.h"
+# include "../view_map/Functions0D.h"
+
+//
+// Functions definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Functions0D {
+
+  // DensityF0D
+  /*! Returns the density of the (result) image evaluated at an Interface0D.
+   *  This density is evaluated using a pixels square window around the
+   *  evaluation point and integrating these values using
+   *  a gaussian.
+   */
+  class LIB_STROKE_EXPORT DensityF0D : public UnaryFunction0D<double>
+  {
+  public:
+    /*! Builds the functor from the gaussian sigma value.
+     *  \param sigma
+     *    sigma indicates the x value for which the gaussian
+     *    function is 0.5. It leads to the window size
+     *    value. (the larger, the smoother)
+     */
+    DensityF0D(double sigma = 2) : UnaryFunction0D<double>() {
+      _filter.setSigma((float)sigma);
+    }
+    /*! Returns the string "DensityF0D"*/
+    string getName() const {
+      return "DensityF0D";
+    }
+    /*! The () operator. */
+    double operator()(Interface0DIterator& iter);
+
+  private:
+
+    GaussianFilter _filter;
+  };
+
+  // LocalAverageDepthF0D
+  /*! Returns the average depth around a point.
+   *  The result is obtained by querying the
+   *  depth buffer on a window around that point.
+   */
+  class LIB_STROKE_EXPORT LocalAverageDepthF0D : public UnaryFunction0D<double>
+  {
+  private:
+    GaussianFilter _filter;
+  public:
+    /*! Builds the functor from the size of the mask that
+     *   will be used.
+     */
+    LocalAverageDepthF0D(real maskSize=5.f) : UnaryFunction0D<double>() {
+      _filter.setSigma((float)maskSize/2.f);
+    }
+    /*! Returns the string "LocalAverageDepthF0D"*/
+    string getName() const {
+      return "LocalAverageDepthF0D";
+    }
+    /*! the () operator.*/
+    double operator()(Interface0DIterator& iter);
+  };
+
+  // ReadMapPixel
+  /*! Reads a pixel in a map.
+   */
+  class LIB_STROKE_EXPORT ReadMapPixelF0D : public UnaryFunction0D<float>
+  {
+  private:
+    const char * _mapName;
+    int _level;
+  public:
+    /*! Builds the functor from name of the 
+     *  Map that must be read.
+     *  \param iMapName
+     *    The name of the map.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     */
+    ReadMapPixelF0D(const char *iMapName, int level) : UnaryFunction0D<float>() {
+      _mapName = iMapName;
+      _level = level;
+    }
+    /*! Returns the string "ReadMapPixelF0D"*/
+    string getName() const {
+      return "ReadMapPixelF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter);
+  };
+  
+  // ReadSteerableViewMapPixel
+  /*! Reads a pixel in one of the level of one of the steerable viewmaps.
+   */
+  class LIB_STROKE_EXPORT ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float>
+  {
+  private:
+    unsigned _orientation;
+    int _level;
+  public:
+    /*! Builds the functor
+     *  \param nOrientation
+     *    The integer belonging to [0,4] indicating the orientation (E,NE,N,NW)
+     *    we are interested in.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     */
+    ReadSteerableViewMapPixelF0D(unsigned nOrientation, int level) : UnaryFunction0D<float>() {
+      _orientation = nOrientation;
+      _level = level;
+    }
+    /*! Returns the string "ReadSteerableViewMapPixelF0D"*/
+    string getName() const {
+      return "ReadSteerableViewMapPixelF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter);
+  };
+
+  // ReadCompleteViewMapPixel
+  /*! Reads a pixel in one of the level of the complete viewmap.
+   */
+  class LIB_STROKE_EXPORT ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float>
+  {
+  private:
+    int _level;
+  public:
+    /*! Builds the functor 
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     */
+    ReadCompleteViewMapPixelF0D(int level) : UnaryFunction0D<float>() {
+      _level = level;
+    }
+    /*! Returns the string "ReadCompleteViewMapPixelF0D"*/
+    string getName() const {
+      return "ReadCompleteViewMapPixelF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter);
+  };
+  
+  // GetViewMapGradientNormF0D
+  /*! Returns the norm of the gradient of the global viewmap density image.
+   */
+  class LIB_STROKE_EXPORT GetViewMapGradientNormF0D: public UnaryFunction0D< float>
+  {
+    private:
+    int _level;
+    float _step;
+  public:
+    /*! Builds the functor 
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     */
+    GetViewMapGradientNormF0D(int level) : UnaryFunction0D<float>() {
+      _level = level;
+      _step = (float)pow(2.0,_level);
+    }
+    /*! Returns the string "GetOccludeeF0D"*/
+    string getName() const {
+      return "GetViewMapGradientNormF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter);
+  };
+} // end of namespace Functions0D
+
+#endif // ADVANCED_FUNCTIONS0D_HPP
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.cpp b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.cpp
new file mode 100755
index 00000000000..ca0e97e68c1
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.cpp
@@ -0,0 +1,108 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "AdvancedFunctions1D.h"
+# include "../view_map/SteerableViewMap.h"
+# include "Canvas.h"
+
+// FIXME
+namespace Functions1D {
+
+  real GetSteerableViewMapDensityF1D::operator()(Interface1D& inter) {
+    SteerableViewMap * svm = Canvas::getInstance()->getSteerableViewMap();
+    Interface0DIterator it = inter.pointsBegin(_sampling);
+    Interface0DIterator itnext = it;++itnext;
+    FEdge *fe;
+    unsigned nSVM;
+    vector<float> values;
+    while(!itnext.isEnd()){
+      Interface0D& i0D = (*it);
+      Interface0D& i0Dnext = (*itnext);
+      fe = i0D.getFEdge(i0Dnext);
+      if(fe == 0){
+        cerr << "GetSteerableViewMapDensityF1D warning: no FEdge between " << i0D.getId() << " and " << i0Dnext.getId() << endl;
+        // compute the direction between these two ???
+        Vec2f dir = i0Dnext.getPoint2D()-i0D.getPoint2D();
+        nSVM = svm->getSVMNumber(dir);
+      }else{
+      nSVM = svm->getSVMNumber(fe->getId().getFirst());
+      }
+      Vec2r m((i0D.getProjectedX()+i0Dnext.getProjectedX())/2.0,
+              (i0D.getProjectedY()+i0Dnext.getProjectedY())/2.0);
+      values.push_back(svm->readSteerableViewMapPixel(nSVM,_level,(int)m[0],(int)m[1]));
+      ++it;++itnext;
+    }
+    float res, res_tmp;
+    vector<float>::iterator v = values.begin(), vend=values.end();
+    unsigned size = 1;
+    switch(_integration) {
+      case MIN:
+        res = *v;++v;
+        for (; v!=vend; ++v) {
+          res_tmp = *v;
+          if (res_tmp < res)
+	          res = res_tmp;
+        }
+        break;
+      case MAX:
+        res = *v;++v;
+        for (; v!=vend; ++v) {
+          res_tmp = *v;
+          if (res_tmp > res)
+	          res = res_tmp;
+        } 
+        break;
+      case FIRST:
+        res = *v;
+        break;
+      case LAST:
+        --vend;
+        res = *vend;
+        break;
+      case MEAN:
+      default:
+        res = *v;++v;
+        for (; v!=vend; ++v, ++size)
+          res += *v;
+        res /= (size ? size : 1);
+        break;
+    } 
+  return res;
+  }  
+
+  double GetDirectionalViewMapDensityF1D::operator()(Interface1D& inter) {
+    //soc unsigned size;
+    double res =  integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
+    return res;
+  } 
+  
+  double GetCompleteViewMapDensityF1D::operator()(Interface1D& inter) {
+    //soc unsigned size;
+    Id id = inter.getId();
+    double res =  integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
+    return res;
+  } 
+
+  real GetViewMapGradientNormF1D::operator()(Interface1D& inter){
+	return integrate(_func, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
+  }
+}
+
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
new file mode 100755
index 00000000000..65b0eec36fd
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h
@@ -0,0 +1,286 @@
+//
+//  Filename         : AdvancedFunctions1D.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Functions taking 1D input
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ADVANCED_FUNCTIONS1D_HPP
+# define ADVANCED_FUNCTIONS1D_HPP
+
+
+# include "AdvancedFunctions0D.h"
+# include "../view_map/Functions1D.h"
+
+//
+// Functions definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Functions1D {
+
+  // DensityF1D
+  /*! Returns the density evaluated for an Interface1D.
+   *  The density is evaluated for a set of points along
+   *  the Interface1D (using the DensityF0D functor)
+   *  with a user-defined sampling and
+   *  then integrated into a single value using
+   *  a user-defined integration method.
+   */
+  class DensityF1D : public UnaryFunction1D<double>
+  {
+  private:
+    float _sampling;
+  public:
+    /*! Builds the functor.
+     *  \param sigma
+     *    Thesigma used in DensityF0D and determining
+     *    the window size used in each density query.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     *  \param sampling
+     *    The resolution used to sample the chain: the corresponding 0D function
+     *    is evaluated at each sample point and the result is obtained by
+     *    combining the resulting values into a single one, following the
+     *    method specified by iType.
+     */
+    DensityF1D(double sigma = 2, IntegrationType iType = MEAN, float sampling=2.f) : UnaryFunction1D<double>(iType), _fun(sigma) {
+      _sampling = sampling;
+    }
+    /*! Destructor */
+    virtual ~DensityF1D(){}
+
+    /*! Returns the string "DensityF1D"*/
+    string getName() const {
+      return "DensityF1D";
+    }
+    /*! the () operator.*/
+    double operator()(Interface1D& inter) {
+      return integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
+    }
+  private:
+    Functions0D::DensityF0D	_fun;
+  };
+
+  // LocalAverageDepthF1D
+  /*! Returns the average depth evaluated for an Interface1D.
+   *  The average depth is evaluated for a set of points along
+   *  the Interface1D (using the LocalAverageDepthF0D functor)
+   *  with a user-defined sampling and
+   *  then integrated into a single value using
+   *  a user-defined integration method.
+   */
+  class LocalAverageDepthF1D : public UnaryFunction1D<double>
+  {
+    public:
+    /*! Builds the functor.
+     *  \param sigma
+     *    The sigma used in DensityF0D and determining
+     *    the window size used in each density query.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    LocalAverageDepthF1D(real sigma, IntegrationType iType = MEAN) 
+      : UnaryFunction1D<double>(iType), _fun(sigma){
+    }
+    /*! Returns the string "LocalAverageDepthF1D"*/
+    string getName() const {
+      return "LocalAverageDepthF1D";
+    }
+    /*! the () operator.*/
+    double operator()(Interface1D& inter) {
+      return integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
+    }
+  private:
+    Functions0D::LocalAverageDepthF0D	_fun;
+  };
+
+  // GetCompleteViewMapDensity
+  /*! Returns the density evaluated for an Interface1D in the 
+   *  complete viewmap image.
+   *  The density is evaluated for a set of points along
+   *  the Interface1D (using the ReadCompleteViewMapPixelF0D functor)
+   *  and then integrated into a single value using
+   *  a user-defined integration method.
+   */
+  class LIB_STROKE_EXPORT GetCompleteViewMapDensityF1D : public UnaryFunction1D<double>
+  {
+  public:
+    /*! Builds the functor.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     *  \param sampling
+     *    The resolution used to sample the chain: the corresponding 0D function
+     *    is evaluated at each sample point and the result is obtained by
+     *    combining the resulting values into a single one, following the
+     *    method specified by iType.
+     */
+    GetCompleteViewMapDensityF1D(unsigned level, IntegrationType iType = MEAN, float sampling=2.f) 
+      : UnaryFunction1D<double>(iType), _fun(level){_sampling = sampling;}
+    /*! Returns the string "GetCompleteViewMapDensityF1D"*/
+    string getName() const {
+      return "GetCompleteViewMapDensityF1D";
+    }
+    /*! the () operator.*/
+    double operator()(Interface1D& inter);
+    
+  private:
+    Functions0D::ReadCompleteViewMapPixelF0D _fun;
+    float _sampling;
+  };
+
+  // GetDirectionalViewMapDensity
+  /*! Returns the density evaluated for an Interface1D in of the 
+   *  steerable viewmaps image.
+   *  The direction telling which Directional map to choose 
+   *  is explicitely specified by the user.
+   *  The density is evaluated for a set of points along
+   *  the Interface1D (using the ReadSteerableViewMapPixelF0D functor)
+   *  and then integrated into a single value using
+   *  a user-defined integration method.
+   */
+  class LIB_STROKE_EXPORT GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double>
+  {
+  public:
+    /*! Builds the functor.
+     *  \param iOrientation
+     *    The number of the directional map 
+     *    we must work with.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     *  \param sampling
+     *    The resolution used to sample the chain: the corresponding 0D function
+     *    is evaluated at each sample point and the result is obtained by
+     *    combining the resulting values into a single one, following the
+     *    method specified by iType.
+     */
+    GetDirectionalViewMapDensityF1D(unsigned iOrientation, unsigned level, IntegrationType iType = MEAN, float sampling=2.f) 
+      : UnaryFunction1D<double>(iType), _fun(iOrientation,level){_sampling = sampling;}
+    /*! Returns the string "GetDirectionalViewMapDensityF1D"*/
+    string getName() const {
+      return "GetDirectionalViewMapDensityF1D";
+    }
+    /*! the () operator.*/
+    double operator()(Interface1D& inter);
+    
+  private:
+    Functions0D::ReadSteerableViewMapPixelF0D _fun;
+    float _sampling;
+  };
+
+  // GetSteerableViewMapDensityF1D
+  /*! Returns the density of the viewmap 
+   *  for a given Interface1D. The density of each 
+   *  FEdge is evaluated in the proper steerable 
+   *  ViewMap depending on its oorientation.
+   */
+  class LIB_STROKE_EXPORT GetSteerableViewMapDensityF1D : public UnaryFunction1D<real>
+  {
+  private:
+    int _level;
+    float _sampling;
+  public:
+    /*! Builds the functor from the level 
+     *  of the pyramid from which the pixel must be read.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     *  \param sampling
+     *    The resolution used to sample the chain: the corresponding 0D function
+     *    is evaluated at each sample point and the result is obtained by
+     *    combining the resulting values into a single one, following the
+     *    method specified by iType.
+     */
+    GetSteerableViewMapDensityF1D(int level,IntegrationType iType = MEAN, float sampling=2.f) : UnaryFunction1D<real>(iType) {
+      _level = level;
+      _sampling = sampling;
+    }
+    /*! Destructor */
+    virtual ~GetSteerableViewMapDensityF1D(){}
+
+    /*! Returns the string "GetSteerableViewMapDensityF1D"*/
+    string getName() const {
+      return "GetSteerableViewMapDensityF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter);
+  };
+
+  // GetViewMapGradientNormF1D
+  /*! Returns the density of the viewmap 
+   *  for a given Interface1D. The density of each 
+   *  FEdge is evaluated in the proper steerable 
+   *  ViewMap depending on its oorientation.
+   */
+  class LIB_STROKE_EXPORT GetViewMapGradientNormF1D : public UnaryFunction1D<real>
+  {
+  private:
+    int _level;
+    float _sampling;
+    Functions0D::GetViewMapGradientNormF0D _func;
+  public:
+    /*! Builds the functor from the level 
+     *  of the pyramid from which the pixel must be read.
+     *  \param level
+     *    The level of the pyramid from which 
+     *    the pixel must be read.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     *  \param sampling
+     *    The resolution used to sample the chain: the corresponding 0D function
+     *    is evaluated at each sample point and the result is obtained by
+     *    combining the resulting values into a single one, following the
+     *    method specified by iType.
+     */
+    GetViewMapGradientNormF1D(int level,IntegrationType iType = MEAN, float sampling=2.f) 
+      : UnaryFunction1D<real>(iType), _func(level) {
+      _level = level;
+      _sampling = sampling;
+    }
+    
+    /*! Returns the string "GetSteerableViewMapDensityF1D"*/
+    string getName() const {
+      return "GetViewMapGradientNormF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter);
+  };
+} // end of namespace Functions1D
+
+#endif // ADVANCED_FUNCTIONS1D_HPP
diff --git a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
new file mode 100755
index 00000000000..f348f8593e5
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h
@@ -0,0 +1,81 @@
+//
+//  Filename         : AdvancedPredicates1D.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class gathering stroke creation algorithms
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ADVANCED_PREDICATES1D_H
+# define ADVANCED_PREDICATES1D_H
+
+# include <string>
+# include "../view_map/Interface1D.h"
+# include "AdvancedFunctions1D.h"
+# include "Predicates1D.h"
+
+//
+// Predicates definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Predicates1D {
+
+  // DensityLowerThanUP1D
+  /*! Returns true if the density evaluated for the
+   *  Interface1D is less than a user-defined density value.
+   */
+  class DensityLowerThanUP1D : public UnaryPredicate1D
+  {
+  public:
+    /*! Builds the functor.
+     *  \param threshold
+     *    The value of the threshold density.
+     *    Any Interface1D having a density lower than
+     *    this threshold will match.
+     *  \param sigma
+     *    The sigma value defining the density evaluation window size
+     *    used in the DensityF0D functor.
+     */
+    DensityLowerThanUP1D(double threshold, double sigma = 2) {
+      _threshold = threshold;
+      _sigma = sigma;
+    }
+    /*! Returns the string "DensityLowerThanUP1D"*/
+    string getName() const {
+      return "DensityLowerThanUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      Functions1D::DensityF1D fun(_sigma);
+      return (fun(inter) < _threshold);
+    }
+  private:
+    double _sigma;
+    double _threshold;
+  };
+
+} // end of namespace Predicates1D
+
+#endif // ADVANCED_PREDICATES1D_H
diff --git a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.cpp b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.cpp
new file mode 100755
index 00000000000..653e0158538
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.cpp
@@ -0,0 +1,423 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../system/PseudoNoise.h"
+#include "../system/RandGen.h"
+#include "AdvancedStrokeShaders.h"
+#include "StrokeIterators.h"
+
+/////////////////////////////////////////
+//
+//  CALLIGRAPHICS SHADER
+//
+/////////////////////////////////////////
+
+
+CalligraphicShader::CalligraphicShader (real iMinThickness, real iMaxThickness,
+					const Vec2f &iOrientation, bool clamp)
+  : StrokeShader()
+{
+  _minThickness=iMinThickness;
+  _maxThickness=iMaxThickness;
+  _orientation = iOrientation;
+  _orientation.normalize();
+  _clamp = clamp;
+}
+
+float ksinToto=0;
+
+void 
+CalligraphicShader::shade(Stroke &ioStroke) const 
+{
+  Interface0DIterator v;
+  Functions0D::VertexOrientation2DF0D fun;
+  StrokeVertex* sv;
+  for(v=ioStroke.verticesBegin();
+      !v.isEnd();
+      ++v)
+    {
+      real thickness;
+      Vec2f vertexOri(fun(v));
+      Vec2r ori2d(-vertexOri[1], vertexOri[0]);
+      ori2d.normalizeSafe();
+      real scal = ori2d * _orientation;
+      sv = dynamic_cast<StrokeVertex*>(&(*v));
+      if (_clamp && (scal<0)) {
+	scal=0.0;
+	sv->attribute().setColor(1,1,1);
+      }
+      else {
+	scal=fabs(scal);
+	sv->attribute().setColor(0,0,0);
+      }
+      thickness=_minThickness+scal*(_maxThickness-_minThickness);
+      if (thickness<0.0)
+	thickness=0.0;
+      sv->attribute().setThickness(thickness/2.0,thickness/2.0);
+    }
+
+}
+
+//void 
+//TipRemoverShader::shade(Stroke &ioStroke) const 
+//{
+//  
+//  StrokeInternal::StrokeVertexIterator v, vend;
+//  for(v=ioStroke.strokeVerticesBegin(), vend=ioStroke.strokeVerticesEnd();
+//      v!=vend;
+//      ++v)
+//    {
+//      if (((*v)->curvilinearAbscissa()<_tipLength) ||
+//	  ((*v)->strokeLength()-(*v)->curvilinearAbscissa()<_tipLength))
+//      { 
+//	  (*v)->attribute().setThickness(0.0, 0.0);
+//	  (*v)->attribute().setColor(1,1,1);
+//      } 
+//    }
+//
+//}
+
+
+
+/////////////////////////////////////////
+//
+//  SPATIAL NOISE SHADER
+//
+/////////////////////////////////////////
+
+static const unsigned NB_VALUE_NOISE = 512;
+
+SpatialNoiseShader::SpatialNoiseShader (float ioamount, float ixScale, int nbOctave, 
+					bool smooth, bool pureRandom)
+  : StrokeShader()
+{
+  _amount = ioamount;
+  if (ixScale==0) _xScale=0;
+  else _xScale=1.0/ixScale/real(NB_VALUE_NOISE);
+  _nbOctave=nbOctave;
+  _smooth=smooth;
+  _pureRandom=pureRandom;
+}
+void
+SpatialNoiseShader::shade(Stroke &ioStroke) const 
+{
+  Interface0DIterator v, v2;
+  v=ioStroke.verticesBegin();
+  Vec2r p(v->getProjectedX(), v->getProjectedY());
+  v2=v; ++v2;
+  Vec2r p0(v2->getProjectedX(), v2->getProjectedY());
+  p0=p+2*(p-p0);
+  StrokeVertex* sv;
+  sv = dynamic_cast<StrokeVertex*>(&(*v));
+  real initU = sv->strokeLength()*real(NB_VALUE_NOISE);
+  if (_pureRandom) initU+=RandGen::drand48()*real(NB_VALUE_NOISE);
+
+  Functions0D::VertexOrientation2DF0D fun;
+  while (!v.isEnd())
+    {
+      sv = dynamic_cast<StrokeVertex*>(&(*v));
+      Vec2r p(sv->getPoint());
+      Vec2r vertexOri(fun(v));
+      Vec2r ori2d(vertexOri[0], vertexOri[1]);
+      ori2d = Vec2r(p-p0);
+      ori2d.normalizeSafe();
+
+      PseudoNoise mynoise;
+      real bruit;
+
+      if (_smooth)
+	bruit=mynoise.turbulenceSmooth(_xScale*sv->curvilinearAbscissa()+initU,
+				       _nbOctave);
+      else
+	bruit=mynoise.turbulenceLinear(_xScale*sv->curvilinearAbscissa()+initU,
+				       _nbOctave);
+      
+      Vec2r noise(-ori2d[1]*_amount*bruit,
+		  ori2d[0]*_amount*bruit);
+
+      sv->setPoint(p[0]+noise[0], p[1]+noise[1]);
+      p0=p;
+
+      ++v;
+    }
+
+}
+
+
+ 
+/////////////////////////////////////////
+//
+//  SMOOTHING SHADER
+//
+/////////////////////////////////////////
+
+
+SmoothingShader::SmoothingShader (int ionbIteration, real iFactorPoint, real ifactorCurvature, real iFactorCurvatureDifference,
+				  real iAnisoPoint, real iAnisoNormal, real iAnisoCurvature, real iCarricatureFactor) 
+  : StrokeShader()
+{
+  _nbIterations=ionbIteration;
+  _factorCurvature=ifactorCurvature;
+  _factorCurvatureDifference=iFactorCurvatureDifference;
+  _anisoNormal=iAnisoNormal;
+  _anisoCurvature=iAnisoCurvature;
+  _carricatureFactor=iCarricatureFactor;
+  _factorPoint=iFactorPoint;
+  _anisoPoint=iAnisoPoint;
+}
+
+
+
+void
+SmoothingShader::shade(Stroke &ioStroke) const 
+{
+  //cerr<<" Smoothing a stroke  "<<endl;
+
+  Smoother smoother(ioStroke);
+  smoother.smooth(_nbIterations, _factorPoint, _factorCurvature, _factorCurvatureDifference, 
+		  _anisoPoint, _anisoNormal, _anisoCurvature, _carricatureFactor);
+}
+
+// SMOOTHER
+////////////////////////////
+
+Smoother::Smoother(Stroke &ioStroke)
+{
+  _stroke=&ioStroke;
+
+  _nbVertices=ioStroke.vertices_size();
+  _vertex=new Vec2r[_nbVertices];
+  _curvature=new real[_nbVertices];
+  _normal=new Vec2r[_nbVertices];
+  StrokeInternal::StrokeVertexIterator v, vend;
+  int i=0;
+  for(v = ioStroke.strokeVerticesBegin(), vend = ioStroke.strokeVerticesEnd();
+      v != vend;
+      ++v)
+    {
+      _vertex[i]=(v)->getPoint();	
+      i++;
+    }
+  Vec2r vec_tmp(_vertex[0]-_vertex[_nbVertices-1]);
+  _isClosedCurve = (vec_tmp.norm() < M_EPSILON);
+
+  _safeTest=(_nbVertices>4);
+}
+
+void Smoother::smooth(int nbIteration, real iFactorPoint, real ifactorCurvature, real iFactorCurvatureDifference,
+		      real iAnisoPoint, real iAnisoNormal, real iAnisoCurvature, real iCarricatureFactor)
+{
+  _factorCurvature=ifactorCurvature;
+  _factorCurvatureDifference=iFactorCurvatureDifference;
+  _anisoNormal=iAnisoNormal;
+  _anisoCurvature=iAnisoCurvature;
+  _carricatureFactor=iCarricatureFactor;
+  _factorPoint=iFactorPoint;
+  _anisoPoint=iAnisoPoint;
+
+  for (int i=0; i<nbIteration; i++)
+    iteration ();
+  copyVertices(); 
+}
+
+real edgeStopping (real x, real sigma)
+{
+  if (sigma==0.0) return 1.0;
+  return exp(-x*x/(sigma*sigma));
+}
+
+void 
+Smoother::iteration ()
+{
+  computeCurvature();
+  for (int i=1; i<_nbVertices-1; i++)
+    {
+      real motionNormal=_factorCurvature*_curvature[i]*
+	edgeStopping(_curvature[i], _anisoNormal);
+
+      real diffC1=_curvature[i]-_curvature[i-1];
+      real diffC2=_curvature[i]-_curvature[i+1];
+      real motionCurvature=edgeStopping(diffC1, _anisoCurvature)*diffC1 +
+	edgeStopping(diffC2, _anisoCurvature)*diffC2;//_factorCurvatureDifference;
+      motionCurvature*=_factorCurvatureDifference;
+      //motionCurvature=_factorCurvatureDifference*(diffC1+diffC2);
+      if (_safeTest)
+	_vertex[i]=Vec2r(_vertex[i]+(motionNormal+motionCurvature)*_normal[i]);
+      Vec2r v1(_vertex[i-1]-_vertex[i]);
+      Vec2r v2(_vertex[i+1]-_vertex[i]);
+      real d1 = v1.norm();
+      real d2 = v2.norm();
+      _vertex[i]=Vec2r(_vertex[i]+ 
+		       _factorPoint*edgeStopping(d2, _anisoPoint)*(_vertex[i-1]-_vertex[i]) +
+		       _factorPoint*edgeStopping(d1, _anisoPoint)*(_vertex[i+1]-_vertex[i]) );
+    }
+
+  if (_isClosedCurve)
+    {
+      real motionNormal=_factorCurvature*_curvature[0]*
+	edgeStopping(_curvature[0], _anisoNormal);
+
+      real diffC1=_curvature[0]-_curvature[_nbVertices-2];
+      real diffC2=_curvature[0]-_curvature[1];
+      real motionCurvature=edgeStopping(diffC1, _anisoCurvature)*diffC1 +
+	edgeStopping(diffC2, _anisoCurvature)*diffC2;//_factorCurvatureDifference;
+      motionCurvature*=_factorCurvatureDifference;
+      //motionCurvature=_factorCurvatureDifference*(diffC1+diffC2);
+      _vertex[0]=Vec2r(_vertex[0]+(motionNormal+motionCurvature)*_normal[0]);
+      _vertex[_nbVertices-1]=_vertex[0];
+    }
+}
+
+
+void 
+Smoother::computeCurvature ()
+{
+  int i;
+  Vec2r BA, BC, normalCurvature;
+  for (i = 1; i < _nbVertices - 1; i++)
+    {
+      BA=_vertex[i-1]-_vertex[i];
+      BC=_vertex[i+1]-_vertex[i];
+      real lba=BA.norm(), lbc=BC.norm();
+      BA.normalizeSafe();
+      BC.normalizeSafe();
+      normalCurvature = BA + BC;
+
+      _normal[i]=Vec2r(-(BC-BA)[1], (BC-BA)[0]);
+      _normal[i].normalizeSafe();
+
+      _curvature[i] = normalCurvature * _normal[i];
+      if (lba+lbc > M_EPSILON)
+	_curvature[i]/=(0.5*lba+lbc);
+    }
+  _curvature[0]=_curvature[1];
+  _curvature[_nbVertices-1]=_curvature[_nbVertices-2];
+  Vec2r di(_vertex[1]-_vertex[0]); 
+  _normal[0] = Vec2r(-di[1], di[0]);
+  _normal[0].normalizeSafe();
+  di=_vertex[_nbVertices-1]-_vertex[_nbVertices-2];
+  _normal[_nbVertices-1]=Vec2r(-di[1], di[0]);
+  _normal[_nbVertices-1].normalizeSafe();
+
+  if (_isClosedCurve)
+    {
+      BA=_vertex[_nbVertices-2]-_vertex[0];
+      BC=_vertex[1]-_vertex[0];
+      real lba=BA.norm(), lbc=BC.norm();
+      BA.normalizeSafe();
+      BC.normalizeSafe();
+      normalCurvature = BA + BC;
+
+      _normal[i]=Vec2r(-(BC-BA)[1], (BC-BA)[0]);
+      _normal[i].normalizeSafe();
+
+      _curvature[i] = normalCurvature * _normal[i];
+      if (lba+lbc > M_EPSILON)
+	_curvature[i]/=(0.5*lba+lbc);
+
+      _normal[_nbVertices-1]=_normal[0];
+      _curvature[_nbVertices-1]=_curvature[0];
+    }
+}
+
+void 
+Smoother::copyVertices ()
+{
+  int i=0;
+  StrokeInternal::StrokeVertexIterator v, vend;
+  for(v=_stroke->strokeVerticesBegin(), vend=_stroke->strokeVerticesEnd();
+      v!=vend;
+      ++v)
+    {
+      const Vec2r p0((v)->getPoint());
+      const Vec2r p1(_vertex[i]);
+      Vec2r p(p0 + _carricatureFactor * (p1 - p0));
+
+      (v)->setPoint(p[0], p[1]);
+      i++;
+    }
+
+}
+
+ 
+/////////////////////////////////////////
+//
+//  OMISSION SHADER
+//
+/////////////////////////////////////////
+
+OmissionShader::OmissionShader (real sizeWindow, real thrVari, real thrFlat, real lFlat)
+{
+  _sizeWindow=sizeWindow;
+  _thresholdVariation=thrVari;
+  _thresholdFlat=thrFlat;
+  _lengthFlat=lFlat;
+}
+
+void
+OmissionShader::shade(Stroke &ioStroke) const 
+{
+  Omitter omi(ioStroke);
+  omi.omit(_sizeWindow, _thresholdVariation, _thresholdFlat, _lengthFlat);
+
+}
+
+
+// OMITTER
+///////////////////////////
+
+Omitter::Omitter (Stroke &ioStroke)
+  :Smoother (ioStroke)
+{
+  StrokeInternal::StrokeVertexIterator v, vend;
+  int i=0;
+  for(v=ioStroke.strokeVerticesBegin(), vend=ioStroke.strokeVerticesEnd();
+      v!=vend;
+      ++v)
+    {
+      _u[i]=(v)->curvilinearAbscissa();
+      i++;
+    }
+
+}
+
+void
+Omitter::omit (real sizeWindow, real thrVari, real thrFlat, real lFlat)
+{
+  _sizeWindow=sizeWindow;
+  _thresholdVariation=thrVari;
+  _thresholdFlat=thrFlat;
+  _lengthFlat=lFlat;
+
+  for (int i=1; i<_nbVertices-1; i++)
+    {
+      if (_u[i]<_lengthFlat) continue;
+      // is the previous segment flat?
+      int j=i-1; 
+      while ((j>=0) && (_u[i]-_u[j]<_lengthFlat))
+	{
+	  if ((_normal[j] * _normal[i]) < _thresholdFlat)
+	    ; // FIXME
+	  j--;
+	}
+
+    }
+}
diff --git a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
new file mode 100755
index 00000000000..b624ccd3e6b
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
@@ -0,0 +1,222 @@
+//
+//  Filename         : AdvancedStrokeShaders.h
+//  Author           : Fredo Durand
+//  Purpose          : Fredo's stroke shaders
+//  Date of creation : 17/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ADVANCEDSTROKESHADERS_H
+# define ADVANCEDSTROKESHADERS_H
+
+# include "BasicStrokeShaders.h"
+
+/*! [ Thickness Shader ].
+ *  Assigns thicknesses to the stroke vertices
+ *  so that the stroke looks like made with a calligraphic tool.
+ *  i.e. The stroke will be the thickest in a main direction,
+ *  the thinest in the direction perpendicular to this one,
+ *  and an interpolation inbetween.
+ */
+class LIB_STROKE_EXPORT CalligraphicShader : public StrokeShader 
+{
+	
+public:
+  /*! Builds the shader.
+   *  \param iMinThickness
+   *    The minimum thickness in the direction perpandicular
+   *    to the main direction.
+   *  \param iMaxThickness
+   *    The maximum thickness in the main direction.
+   *  \param iOrientation
+   *    The 2D vector giving the main direction.
+   *  \param clamp
+   *    Tells ???
+   */
+  CalligraphicShader (real iMinThickness, real iMaxThickness,
+		      const Vec2f &iOrientation, bool clamp);
+  /*! Destructor. */
+  virtual ~CalligraphicShader () {}
+  /*! The shading method */
+  virtual void shade(Stroke &ioStroke) const;
+protected:
+  real _maxThickness;
+  real _minThickness;
+  Vec2f _orientation; 
+  bool _clamp;
+};
+
+/*! [ Geometry Shader ].
+ *  Spatial Noise stroke shader.
+ *  Moves the vertices to make the stroke more noisy.
+ *  @see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
+ */
+class LIB_STROKE_EXPORT SpatialNoiseShader : public StrokeShader 
+{
+public:
+  /*! Builds the shader.
+   *  \param iAmount
+   *    The amplitude of the noise.
+   *  \param ixScale
+   *    The noise frequency
+   *  \param nbOctave
+   *    The number of octaves
+   *  \param smooth
+   *    If you want the noise to be smooth
+   *  \param pureRandom
+   *    If you don't want any coherence
+   */
+  SpatialNoiseShader (float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom);
+  /*! Destructor. */
+  virtual ~SpatialNoiseShader () {}
+  /*! The shading method. */
+  virtual void shade(Stroke &ioStroke) const;
+
+protected:
+
+  float _amount;
+  float _xScale;
+  int _nbOctave;
+  bool _smooth;
+  bool _pureRandom;
+};
+
+/*! [ Geometry Shader ].
+ *  Smoothes the stroke.
+ *  (Moves the vertices to make the stroke smoother).
+ *  Uses curvature flow to converge towards a curve of constant
+ *  curvature. The diffusion method we use is anisotropic
+ *  to prevent the diffusion accross corners.
+ *  @see \htmlonly <a href=/smoothing/smoothing.html>smoothing/smoothing.html</a> endhtmlonly
+ */
+class LIB_STROKE_EXPORT SmoothingShader : public StrokeShader 
+{
+public:
+  /*! Builds the shader.
+   *  \param iNbIteration
+   *    The number of iterations. (400)
+   *  \param iFactorPoint
+   *    0
+   *  \param ifactorCurvature
+   *    0
+   *  \param iFactorCurvatureDifference
+   *    0.2
+   *  \param iAnisoPoint
+   *    0
+   *  \param iAnisNormal
+   *    0
+   *  \param iAnisoCurvature
+   *    0
+   *  \param icarricatureFactor
+   *    1
+   */
+  SmoothingShader (int iNbIteration, real iFactorPoint, real ifactorCurvature, real iFactorCurvatureDifference,
+		   real iAnisoPoint, real iAnisoNormal, real iAnisoCurvature, real icarricatureFactor);
+  /*! Destructor. */
+  virtual ~SmoothingShader () {}
+
+  /*! The shading method. */
+  virtual void shade(Stroke &ioStroke) const;
+
+protected:
+
+  int _nbIterations;
+  real _factorPoint;
+  real _factorCurvature;
+  real _factorCurvatureDifference;
+  real _anisoPoint;
+  real _anisoNormal;
+  real _anisoCurvature;
+  real _carricatureFactor;
+};
+
+class LIB_STROKE_EXPORT Smoother
+{
+public:
+  Smoother (Stroke &ioStroke);
+	
+  virtual ~Smoother () {}
+
+  void smooth (int nbIterations, real iFactorPoint, real ifactorCurvature, real iFactorCurvatureDifference,
+	       real iAnisoPoint, real iAnisoNormal, real iAnisoCurvature, real icarricatureFactor);
+  void computeCurvature ();
+
+protected:
+  real _factorPoint;
+  real _factorCurvature;
+  real _factorCurvatureDifference;
+  real _anisoPoint;
+  real _anisoNormal;
+  real _anisoCurvature;
+  real _carricatureFactor;
+
+  void iteration();
+  void copyVertices ();
+
+  Stroke *_stroke;
+  int _nbVertices;
+  Vec2r *_vertex;
+  Vec2r *_normal;
+  real *_curvature;
+  bool *_isFixedVertex;
+
+  bool _isClosedCurve;
+  bool _safeTest;
+};
+
+class LIB_STROKE_EXPORT Omitter : public Smoother 
+{
+public:
+  Omitter (Stroke &ioStroke);
+  virtual ~Omitter () {}
+
+  void omit (real sizeWindow, real thrVari, real thrFlat, real lFlat);
+protected:
+  real *_u;
+
+  real _sizeWindow;
+  real _thresholdVariation;
+  real _thresholdFlat;
+  real _lengthFlat;
+};
+
+/*! Omission shader 
+ */
+class LIB_STROKE_EXPORT OmissionShader : public StrokeShader 
+{
+public:
+  OmissionShader (real sizeWindow, real thrVari, real thrFlat, real lFlat);
+  virtual ~OmissionShader () {}
+
+  virtual void shade(Stroke &ioStroke) const;
+
+protected:
+
+  real _sizeWindow;
+  real _thresholdVariation;
+  real _thresholdFlat;
+  real _lengthFlat;
+};
+
+#endif // ADVANCEDSTROKESHADERS_H
diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp
new file mode 100755
index 00000000000..05cc13fd96c
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp
@@ -0,0 +1,1118 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <fstream>
+#include "BasicStrokeShaders.h"
+#include "../system/PseudoNoise.h"
+#include "../system/RandGen.h"
+#include "../view_map/Functions0D.h"
+#include "../view_map/Functions1D.h"
+#include "AdvancedFunctions0D.h"
+#include "AdvancedFunctions1D.h"
+#include "StrokeIterators.h"
+#include "../system/StringUtils.h"
+#include "StrokeRenderer.h"
+#include "StrokeIO.h"
+
+//soc #include <qimage.h>
+//soc #include <QString>
+extern "C" {
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+}
+
+// Internal function
+
+// soc
+// void convert(const QImage& iImage, float **oArray, unsigned &oSize) {
+//   oSize = iImage.width();
+//   *oArray = new float[oSize];
+//   for(unsigned i=0; i<oSize; ++i) {
+//     QRgb rgb = iImage.pixel(i,0);
+//     (*oArray)[i] = ((float)qBlue(rgb))/255.f;
+//   }
+// }
+void convert(ImBuf *imBuf, float **oArray, unsigned &oSize) {
+	oSize = imBuf->x;
+  	*oArray = new float[oSize];
+
+	char *pix;
+	for(unsigned i=0; i < oSize; ++i) {
+		pix = (char*) imBuf->rect + i*4;
+    	(*oArray)[i] = ((float) pix[2] )/255.f;
+  	}
+}
+
+namespace StrokeShaders {
+
+  //
+  //  Thickness modifiers
+  //
+  //////////////////////////////////////////////////////////
+
+  void ConstantThicknessShader::shade(Stroke& stroke) const
+  {
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int i=0;
+    int size = stroke.strokeVerticesSize();
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	if((1 == i) || (size-2 == i))
+	  v->attribute().setThickness(_thickness/4.0,_thickness/4.0);
+	if((0 == i) || (size-1 == i))
+	  v->attribute().setThickness(0,0);
+      
+	v->attribute().setThickness(_thickness/2.0, _thickness/2.0);
+      }
+  } 
+
+  void ConstantExternThicknessShader::shade(Stroke& stroke) const
+  {
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int i=0;
+    int size = stroke.strokeVerticesSize();
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	if((1 == i) || (size-2 == i))
+	  v->attribute().setThickness(_thickness/2.0,0);
+	if((0 == i) || (size-1 == i))
+	  v->attribute().setThickness(0,0);
+      
+	v->attribute().setThickness(_thickness, 0);
+      }
+  } 
+
+  void IncreasingThicknessShader::shade(Stroke& stroke) const
+  {
+
+    int n=stroke.strokeVerticesSize()-1;
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int i=0;
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+ 
+	++v)
+      {
+	float t;
+	if(i < (float)n/2.f)
+	  t = (1.0-(float)i/(float)n)*_ThicknessMin + (float)i/(float)n*_ThicknessMax;
+	else
+	  t = (1.0-(float)i/(float)n)*_ThicknessMax + (float)i/(float)n*_ThicknessMin;
+	v->attribute().setThickness(t/2.0, t/2.0);
+	++i;
+      }
+  } 
+
+  void ConstrainedIncreasingThicknessShader::shade(Stroke& stroke) const
+  {
+    float slength = stroke.getLength2D();
+    float maxT = min(_ratio*slength,_ThicknessMax);
+    int n=stroke.strokeVerticesSize()-1;
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int i=0;
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+ 
+	++v)
+      {
+	float t;
+	if(i < (float)n/2.f)
+	  t = (1.0-(float)i/(float)n)*_ThicknessMin + (float)i/(float)n*maxT;
+	else
+	  t = (1.0-(float)i/(float)n)*maxT + (float)i/(float)n*_ThicknessMin;
+	v->attribute().setThickness(t/2.0, t/2.0);
+	if(i == n-1)
+	  v->attribute().setThickness(_ThicknessMin/2.0, _ThicknessMin/2.0);
+	++i;
+      }
+  } 
+
+
+  void LengthDependingThicknessShader::shade(Stroke& stroke) const
+  {
+    float step = (_maxThickness-_minThickness)/3.f;
+    float l = stroke.getLength2D();
+    float thickness = 0.0;
+    if(l>300.f)
+      thickness = _minThickness+3.f*step;
+    else if((l< 300.f) && (l>100.f))
+      thickness = _minThickness+2.f*step;
+    else if((l<100.f) && (l>50.f))
+      thickness = _minThickness+1.f*step;
+    else if(l< 50.f)
+      thickness = _minThickness;
+
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int i=0;
+    int size = stroke.strokeVerticesSize();
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	if((1 == i) || (size-2 == i))
+	  v->attribute().setThickness(thickness/4.0,thickness/4.0);
+	if((0 == i) || (size-1 == i))
+	  v->attribute().setThickness(0,0);
+      
+	v->attribute().setThickness(thickness/2.0, thickness/2.0);
+      }
+  }
+
+
+  ThicknessVariationPatternShader::ThicknessVariationPatternShader(const string pattern_name,
+									float iMinThickness,
+									float iMaxThickness,
+									bool stretch)
+    : StrokeShader() {
+    _stretch = stretch;
+    _minThickness = iMinThickness;
+    _maxThickness = iMaxThickness;
+    ImBuf *image = 0; //soc
+    vector<string> pathnames;
+    StringUtils::getPathName(TextureManager::Options::getPatternsPath(),
+			     pattern_name,
+			     pathnames);
+    for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++) {
+      ifstream ifs(j->c_str());
+      if (ifs.is_open()) {
+		//soc image.load(j->c_str());
+		image = IMB_loadiffname(j->c_str(), 0);
+		break;
+      }
+    }
+    if (image == 0) //soc
+      cerr << "Error: cannot find pattern \"" << pattern_name
+	   << "\" - check the path in the Options" << endl;
+    else
+      convert(image, &_aThickness, _size);
+  }
+  
+  void ThicknessVariationPatternShader::shade(Stroke& stroke) const
+  { 
+    StrokeInternal::StrokeVertexIterator v, vend;
+    float *array = 0;
+    int size;
+    array = _aThickness;
+    size = _size;
+    // }
+    int vert_size = stroke.strokeVerticesSize();
+    int sig = 0;
+    unsigned index;
+    const float* originalThickness;
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	originalThickness = v->attribute().getThickness();
+	if (_stretch) {
+	float tmp = v->u()*(_size-1);
+	index = (unsigned)floor(tmp);
+	  if((tmp-index) > (index+1-tmp))
+	    ++index;
+	}
+	else
+	  index = (unsigned)floor(v->curvilinearAbscissa());
+	index %= _size;
+	float thicknessR = array[index]*originalThickness[0];
+	float thicknessL = array[index]*originalThickness[1];
+	if(thicknessR+thicknessL < _minThickness)
+	  {
+	    thicknessL = _minThickness/2.f;
+	    thicknessR = _minThickness/2.f;
+	  }
+	if(thicknessR+thicknessL > _maxThickness)
+	  {
+	    thicknessL = _maxThickness/2.f;
+	    thicknessR = _maxThickness/2.f;
+	  }
+	if((sig==0) || (sig==vert_size-1))
+	  v->attribute().setThickness(1, 1);
+	else
+	  v->attribute().setThickness(thicknessR, thicknessL);
+	++sig;
+      }
+  } 
+
+
+  static const unsigned NB_VALUE_NOISE = 512;
+  ThicknessNoiseShader::ThicknessNoiseShader()
+    :StrokeShader()
+  {_amplitude=1.f;_scale=1.f/2.f/(float)NB_VALUE_NOISE;}
+
+  ThicknessNoiseShader::ThicknessNoiseShader(float iAmplitude, float iPeriod)
+    :StrokeShader()
+  {_amplitude=iAmplitude;_scale=1.f/iPeriod/(float)NB_VALUE_NOISE;}
+
+
+  void ThicknessNoiseShader::shade(Stroke& stroke) const
+  {  
+    StrokeInternal::StrokeVertexIterator v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+    real initU1=v->strokeLength()*real(NB_VALUE_NOISE)+RandGen::drand48()*real(NB_VALUE_NOISE);
+    real initU2=v->strokeLength()*real(NB_VALUE_NOISE)+RandGen::drand48()*real(NB_VALUE_NOISE);
+  
+    real bruit, bruit2;
+    PseudoNoise mynoise, mynoise2;
+    for(;
+	v!=vend;
+	++v)
+      {
+     
+	bruit=mynoise.turbulenceSmooth(_scale*v->curvilinearAbscissa()+initU1,
+				       2); //2 : nbOctaves
+	bruit2=mynoise2.turbulenceSmooth(_scale*v->curvilinearAbscissa()+initU2,
+					 2); //2 : nbOctaves
+	const float *originalThickness = v->attribute().getThickness();
+	float r = bruit*_amplitude+originalThickness[0];
+	float l = bruit2*_amplitude+originalThickness[1];
+	v->attribute().setThickness(r,l);
+      }
+  
+  }
+
+  //
+  //  Color shaders
+  //
+  ///////////////////////////////////////////////////////////////////////////////
+
+  void ConstantColorShader::shade(Stroke& stroke) const
+  {
+    StrokeInternal::StrokeVertexIterator v, vend;
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	v->attribute().setColor(_color[0], _color[1], _color[2]);
+	v->attribute().setAlpha(_color[3]);
+      }
+  }
+
+  void IncreasingColorShader::shade(Stroke& stroke) const
+  {
+    StrokeInternal::StrokeVertexIterator v, vend;
+    int n=stroke.strokeVerticesSize()-1;
+    int yo=0;
+    float newcolor[4];
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+  
+	++v)
+      {
+	for(int i=0; i<4; ++i) 
+	  {
+	    newcolor[i] = (1.0-(float)yo/(float)n)*_colorMin[i] + (float)yo/(float)n*_colorMax[i];
+	  }
+	v->attribute().setColor(newcolor[0], newcolor[1], newcolor[2]);
+	v->attribute().setAlpha(newcolor[3]);
+	++yo;
+      }
+  }
+
+  ColorVariationPatternShader::ColorVariationPatternShader(const string pattern_name,
+							   bool stretch)
+    : StrokeShader() {
+    _stretch = stretch;
+    ImBuf *image = 0; //soc
+    vector<string> pathnames;
+    StringUtils::getPathName(TextureManager::Options::getPatternsPath(),
+			     pattern_name,
+			     pathnames);
+    for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++) {
+      ifstream ifs(j->c_str());
+      if (ifs.is_open()) {
+		image = IMB_loadiffname(j->c_str(), 0); //soc
+		break;
+      }
+    }
+    if (image == 0) //soc
+      cerr << "Error: cannot find pattern \"" << pattern_name
+	   << "\" - check the path in the Options" << endl;
+    else
+      convert(image, &_aVariation, _size);
+  }
+  
+  void ColorVariationPatternShader::shade(Stroke& stroke) const
+  {
+    StrokeInternal::StrokeVertexIterator v, vend;
+    unsigned index;
+    for(v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+	v!=vend;
+	++v)
+      {
+	const float *originalColor = v->attribute().getColor();
+	if (_stretch) {
+	  float tmp = v->u()*(_size-1);
+	  index = (unsigned)floor(tmp);
+	  if((tmp-index) > (index+1-tmp))
+	    ++index;
+	}
+	else
+	  index = (unsigned)floor(v->curvilinearAbscissa());
+	index %= _size;
+	float r = _aVariation[index]*originalColor[0];
+	float g = _aVariation[index]*originalColor[1];
+	float b = _aVariation[index]*originalColor[2];
+	v->attribute().setColor(r,g,b);
+      }
+  }
+
+  void MaterialColorShader::shade(Stroke& stroke) const
+  {
+    Interface0DIterator v, vend;
+    Functions0D::MaterialF0D fun;
+    StrokeVertex *sv;
+    for(v=stroke.verticesBegin(), vend=stroke.verticesEnd();
+	v!=vend;
+	++v)
+      {
+    const float *diffuse = fun(v).diffuse();
+    sv = dynamic_cast<StrokeVertex*>(&(*v));
+	  sv->attribute().setColor(diffuse[0]*_coefficient, diffuse[1]*_coefficient, diffuse[2]*_coefficient);
+	  sv->attribute().setAlpha(diffuse[3]);
+      }
+  }
+
+
+  void CalligraphicColorShader::shade(Stroke& stroke) const
+  {
+    Interface0DIterator v;
+    Functions0D::VertexOrientation2DF0D fun;
+    StrokeVertex* sv;
+    for(v=stroke.verticesBegin();
+	!v.isEnd();
+	++v)
+      {
+	Vec2f vertexOri(fun(v));
+	Vec2d ori2d(-vertexOri[1], vertexOri[0]);
+	ori2d.normalizeSafe();
+	real scal = ori2d * _orientation;
+	sv = dynamic_cast<StrokeVertex*>(&(*v));
+	if ((scal<0)) 
+	  sv->attribute().setColor(0,0,0);
+	else
+	  sv->attribute().setColor(1,1,1);
+      }
+  }
+
+
+  ColorNoiseShader::ColorNoiseShader()
+    :StrokeShader()
+  {_amplitude=1.f;_scale=1.f/2.f/(float)NB_VALUE_NOISE;}
+
+  ColorNoiseShader::ColorNoiseShader(float iAmplitude, float iPeriod)
+    :StrokeShader()
+  {_amplitude=iAmplitude;_scale=1.f/iPeriod/(float)NB_VALUE_NOISE;}
+
+
+  void ColorNoiseShader::shade(Stroke& stroke) const
+  {  
+    StrokeInternal::StrokeVertexIterator v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+    real initU=v->strokeLength()*real(NB_VALUE_NOISE)+RandGen::drand48()*real(NB_VALUE_NOISE);
+  
+    real bruit;
+    PseudoNoise mynoise;
+    for(;
+	v!=vend;
+	++v)
+      {
+     
+	bruit=mynoise.turbulenceSmooth(_scale*v->curvilinearAbscissa()+initU,
+				       2); //2 : nbOctaves
+	const float *originalColor = v->attribute().getColor();
+	float r = bruit*_amplitude+originalColor[0];
+	float g = bruit*_amplitude+originalColor[1];
+	float b = bruit*_amplitude+originalColor[2];
+	v->attribute().setColor(r,g,b);
+      }
+  
+  }
+
+ 
+  //
+  //  Texture Shaders
+  //
+  ///////////////////////////////////////////////////////////////////////////////
+
+  void TextureAssignerShader::shade(Stroke& stroke) const
+  {
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/charcoalAlpha.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/washbrushAlpha.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/oil.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/oilnoblend.bmp", Stroke::HUMID_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/charcoalAlpha.bmp", Stroke::DRY_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/washbrushAlpha.bmp", Stroke::DRY_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/opaqueDryBrushAlpha.bmp", Stroke::OPAQUE_MEDIUM);
+  //  getBrushTextureIndex(TEXTURES_DIR "/brushes/opaqueBrushAlpha.bmp", Stroke::OPAQUE_MEDIUM);
+
+    TextureManager * instance = TextureManager::getInstance();
+    if(!instance)
+      return;
+    string pathname;
+    Stroke::MediumType mediumType;
+    bool hasTips = false;
+    switch(_textureId)
+    {
+    case 0:
+      //pathname = TextureManager::Options::getBrushesPath() + "/charcoalAlpha.bmp";
+			pathname = "/charcoalAlpha.bmp";
+      mediumType = Stroke::HUMID_MEDIUM;
+      hasTips = false;
+      break;
+    case 1:
+      pathname = "/washbrushAlpha.bmp";
+      mediumType = Stroke::HUMID_MEDIUM;
+      hasTips = true;
+      break;
+    case 2:
+      pathname = "/oil.bmp";
+      mediumType = Stroke::HUMID_MEDIUM;
+      hasTips = true;
+      break;
+    case 3:
+      pathname = "/oilnoblend.bmp";
+      mediumType = Stroke::HUMID_MEDIUM;
+      hasTips = true;
+      break;
+    case 4:
+      pathname = "/charcoalAlpha.bmp";
+      mediumType = Stroke::DRY_MEDIUM;
+      hasTips = false;
+      break;
+    case 5:
+      mediumType = Stroke::DRY_MEDIUM;
+      hasTips = true;
+      break;
+    case 6:
+      pathname = "/opaqueDryBrushAlpha.bmp";
+      mediumType = Stroke::OPAQUE_MEDIUM;
+      hasTips = true;
+      break;
+    case 7:
+      pathname = "/opaqueBrushAlpha.bmp";
+      mediumType = Stroke::OPAQUE_MEDIUM;
+      hasTips = true;
+      break;
+    default:
+      pathname = "/smoothAlpha.bmp";
+      mediumType = Stroke::OPAQUE_MEDIUM;
+      hasTips = false;
+      break;
+    }
+    unsigned int texId = instance->getBrushTextureIndex(pathname, mediumType);
+    stroke.setMediumType(mediumType);
+    stroke.setTips(hasTips);
+    stroke.setTextureId(texId);
+  }
+
+  // FIXME
+  void StrokeTextureShader::shade(Stroke& stroke) const
+  {
+    TextureManager * instance = TextureManager::getInstance();
+    if(!instance)
+      return;
+    string pathname = TextureManager::Options::getBrushesPath() + "/" + _texturePath;
+    unsigned int texId = instance->getBrushTextureIndex(pathname, _mediumType);
+    stroke.setMediumType(_mediumType);
+    stroke.setTips(_tips);
+    stroke.setTextureId(texId);
+  }
+
+  //
+  //  Geometry Shaders
+  //
+  ///////////////////////////////////////////////////////////////////////////////
+
+  void BackboneStretcherShader::shade(Stroke& stroke) const
+  {
+    float l=stroke.getLength2D();
+    if(l <= 50)
+      return;
+
+    StrokeInternal::StrokeVertexIterator v0=stroke.strokeVerticesBegin();
+    StrokeInternal::StrokeVertexIterator v1=v0;++v1;
+    StrokeInternal::StrokeVertexIterator vn=stroke.strokeVerticesEnd();--vn;
+    StrokeInternal::StrokeVertexIterator vn_1=vn;--vn_1;
+    
+    
+    Vec2d first((v0)->x(), (v0)->y());
+    Vec2d last((vn)->x(), (vn)->y());
+
+    Vec2d d1(first-Vec2d((v1)->x(), (v1)->y())); 
+    d1.normalize();
+    Vec2d dn(last-Vec2d((vn_1)->x(), (vn_1)->y()));
+    dn.normalize();
+
+    Vec2d newFirst(first+_amount*d1);
+    (v0)->setPoint(newFirst[0], newFirst[1]);
+    Vec2d newLast(last+_amount*dn);
+    (vn)->setPoint(newLast[0], newLast[1]);
+  }
+
+  void SamplingShader::shade(Stroke& stroke) const
+  {
+    stroke.Resample(_sampling);
+  }
+
+  void ExternalContourStretcherShader::shade(Stroke& stroke) const
+  { 
+    //float l=stroke.getLength2D();
+    Interface0DIterator it=stroke.verticesBegin();
+    Functions0D::Normal2DF0D fun;
+    StrokeVertex* sv;
+    while (!it.isEnd())
+      {
+	Vec2f n(fun(it));
+	sv = dynamic_cast<StrokeVertex*>(&(*it));
+	Vec2d newPoint(sv->x()+_amount*n.x(), sv->y()+_amount*n.y());
+	sv->setPoint(newPoint[0], newPoint[1]);
+	++it;
+      }
+  }
+
+  void BSplineShader::shade(Stroke& stroke) const
+  {
+    if(stroke.strokeVerticesSize() < 4)
+      return;
+
+    // Find the new vertices
+    vector<Vec2d> newVertices;
+    double t=0.f;
+    float _sampling = 5.f;
+
+    StrokeInternal::StrokeVertexIterator p0,p1,p2,p3, end;
+    p0 = stroke.strokeVerticesBegin();
+    p1 = p0;
+    p2 = p1;
+    p3 = p2;
+    end = stroke.strokeVerticesEnd();
+    double a[4],b[4];
+    int n=0;
+    while(p1 != end)
+      {
+	//      if(p1 == end)
+	//        p1 = p0;
+	if(p2 == end)
+	  p2 = p1;
+	if(p3 == end)
+	  p3 = p2;
+	// compute new matrix
+	a[0] = (-(p0)->x()+3*(p1)->x()-3*(p2)->x()+(p3)->x())/6.0;
+	a[1] = (3*(p0)->x()-6*(p1)->x()+3*(p2)->x())/6.0;
+	a[2] = (-3*(p0)->x()+3*(p2)->x())/6.0;
+	a[3] = ((p0)->x()+4*(p1)->x()+(p2)->x())/6.0;
+
+	b[0] = (-(p0)->y()+3*(p1)->y()-3*(p2)->y()+(p3)->y())/6.0;
+	b[1] = (3*(p0)->y()-6*(p1)->y()+3*(p2)->y())/6.0;
+	b[2] = (-3*(p0)->y()+3*(p2)->y())/6.0;
+	b[3] = ((p0)->y()+4*(p1)->y()+(p2)->y())/6.0;
+
+
+	// draw the spline depending on resolution:
+	Vec2d p1p2((p2)->x()-(p1)->x(), (p2)->y()-(p1)->y());
+	double norm = p1p2.norm();
+	//t = _sampling/norm;
+	t=0;
+	while(t<1)
+	  { 
+	    newVertices.push_back(Vec2d((a[3] + t*(a[2] + t*(a[1] + t*a[0]))), 
+					(b[3] + t*(b[2] + t*(b[1] + t*b[0])))));
+	    t = t + _sampling/norm;
+	  } 
+	if(n > 2)
+	  {
+	    ++p0;
+	    ++p1;
+	    ++p2;
+	    ++p3;
+	  }
+	else
+	  {
+	    if(n==0)
+	      ++p3;
+	    if(n==1)
+	      {++p2;++p3;}
+	    if(n==2)
+	      {++p1;++p2;++p3;}
+	    ++n;
+	  }
+      }
+    //last point:
+    newVertices.push_back(Vec2d((p0)->x(), (p0)->y()));
+    
+    int originalSize = newVertices.size();
+    _sampling = stroke.ComputeSampling(originalSize);
+
+    // Resample and set x,y coordinates
+    stroke.Resample(_sampling);
+    int newsize = stroke.strokeVerticesSize();
+    
+    int nExtraVertex=0;
+    if(newsize < originalSize)
+      cerr << "Warning: unsufficient resampling" << endl;
+    else
+      {
+	nExtraVertex = newsize - originalSize;
+      }
+
+    // assigns the new coordinates:
+    vector<Vec2d>::iterator p,pend;
+    p=newVertices.begin();pend=newVertices.end();
+    vector<Vec2d>::iterator last = p;
+    n=0;
+    StrokeInternal::StrokeVertexIterator it=stroke.strokeVerticesBegin(), itend=stroke.strokeVerticesEnd();
+    it=stroke.strokeVerticesBegin();
+    for(;
+	((it!=itend) && (p!=pend));
+	++it)
+      {
+	it->setX(p->x());
+	it->setY(p->y());
+	last = p;
+	++p;
+	++n;
+      }
+    // nExtraVertex should stay unassigned
+    for(int i=0; i< nExtraVertex; ++i)
+      {
+	it->setX(last->x());
+	it->setY(last->y());
+	if(it.isEnd())
+	  cerr << "Warning: Problem encountered while creating B-spline" << endl;
+	++it;
+	++n;
+      }
+  }
+
+  //!! Bezier curve stroke shader
+  void BezierCurveShader::shade(Stroke& stroke) const
+  { 
+    if(stroke.strokeVerticesSize() < 4)
+      return;
+
+    // Build the Bezier curve from this set of data points:    
+    vector<Vec2d> data;
+    StrokeInternal::StrokeVertexIterator v=stroke.strokeVerticesBegin(), vend=stroke.strokeVerticesEnd();
+    data.push_back(Vec2d(v->x(), v->y()));//first one
+    StrokeInternal::StrokeVertexIterator previous = v;++v;
+    for(;
+	v!=vend;
+	++v)
+      {
+	if(!((fabs(v->x() -(previous)->x())<M_EPSILON) && ((fabs(v->y() - (previous)->y())<M_EPSILON))))
+	  data.push_back(Vec2d(v->x(), v->y()));
+	previous = v;
+      }
+    
+    //    Vec2d tmp;bool equal=false;
+    //    if(data.front() == data.back())
+    //    {
+    //      tmp = data.back();
+    //      data.pop_back();
+    //      equal=true;
+    //    }
+    // here we build the bezier curve
+    BezierCurve bcurve(data, _error);
+
+    // bad performances are here !!! // FIXME
+    vector<Vec2d> CurveVertices;
+    vector<BezierCurveSegment*>& bsegments = bcurve.segments();
+    vector<BezierCurveSegment*>::iterator s=bsegments.begin(),send=bsegments.end();
+    vector<Vec2d>& segmentsVertices = (*s)->vertices();
+    vector<Vec2d>::iterator p,pend;
+    // first point
+    CurveVertices.push_back(segmentsVertices[0]);
+    for(;
+	s!=send;
+	++s)
+      {
+	segmentsVertices = (*s)->vertices();
+	p=segmentsVertices.begin(); pend=segmentsVertices.end();
+	++p;
+	for(;
+	    p!=pend;
+	    ++p)
+	  {
+	    CurveVertices.push_back((*p));
+	  }
+      }
+
+    //if(equal)
+    //    if(data.back() == data.front())
+    //    {
+    //      vector<Vec2d>::iterator d=data.begin(), dend=data.end();
+    //      cout << "ending point = starting point" << endl;
+    //      cout << "---------------DATA----------" << endl;
+    //      for(;
+    //      d!=dend;
+    //      ++d)
+    //      {
+    //        cout << d->x() << "-" << d->y() << endl;
+    //      }
+    //      cout << "--------------BEZIER RESULT----------" << endl;
+    //      d=CurveVertices.begin(), dend=CurveVertices.end();
+    //      for(;d!=dend;++d)
+    //      {
+    //        cout << d->x() << "-" << d->y() << endl;
+    //      }
+    //    }
+
+    // Resample the Stroke depending on the number of 
+    // vertices of the bezier curve:
+    int originalSize = CurveVertices.size();
+    //float sampling = stroke.ComputeSampling(originalSize);
+    //stroke.Resample(sampling);
+    stroke.Resample(originalSize);
+    int newsize = stroke.strokeVerticesSize();
+    int nExtraVertex=0;
+    if(newsize < originalSize)
+      cerr << "Warning: unsufficient resampling" << endl;
+    else
+      {
+	//cout << "Oversampling" << endl;
+        nExtraVertex = newsize - originalSize;
+        if(nExtraVertex != 0)
+          cout << "Bezier Shader : Stroke " << stroke.getId() << " have not been resampled" << endl;
+      }
+
+    // assigns the new coordinates:
+    p=CurveVertices.begin();pend=CurveVertices.end();
+    vector<Vec2d>::iterator last = p;
+    int n=0;
+    StrokeInternal::StrokeVertexIterator it=stroke.strokeVerticesBegin(), itend=stroke.strokeVerticesEnd();
+    //    while(p!=pend)
+    //    { 
+    //      ++n;
+    //      ++p;
+    //    }
+    it=stroke.strokeVerticesBegin();
+    for(;
+	((it!=itend) && (p!=pend));
+	++it)
+      {
+	it->setX(p->x());
+	it->setY(p->y());
+	//      double x = p->x();
+	//      double y = p->y();
+	//      cout << "x = " << x << "-" << "y = " << y << endl;
+	last = p;
+	++p;
+	++n;
+      }
+
+    // Deal with extra vertices:
+    if(nExtraVertex == 0)
+      return;
+
+    // nExtraVertex should stay unassigned
+    vector<StrokeAttribute> attributes;
+    vector<StrokeVertex*> verticesToRemove;
+    for(int i=0; i< nExtraVertex; ++i)
+    {
+      verticesToRemove.push_back(&(*it));
+      if(it.isEnd())
+        cout << "fucked up" << endl;
+      ++it;
+      ++n;
+    }
+    it=stroke.strokeVerticesBegin();
+    for(;
+    it!=itend;
+    ++it)
+    {
+      attributes.push_back(it->attribute());
+    }
+
+    for(vector<StrokeVertex*>::iterator vr=verticesToRemove.begin(), vrend=verticesToRemove.end();
+    vr!=vrend;
+    ++vr)
+    {
+      stroke.RemoveVertex(*vr);
+    }
+    it=stroke.strokeVerticesBegin();
+    itend=stroke.strokeVerticesEnd();
+    vector<StrokeAttribute>::iterator a=attributes.begin(), aend=attributes.end();
+    int index = 0;
+    int index1 = (int)floor((float)originalSize/2.0);
+    int index2 = index1+nExtraVertex;
+    for(;
+    (it!=itend) && (a!=aend);
+    ++it)
+    {
+      (it)->setAttribute(*a);
+      if((index <= index1)||(index>index2))
+        ++a;
+      ++index;
+    }
+  } 
+
+  void InflateShader::shade(Stroke& stroke) const
+  {
+    // we're computing the curvature variance of the stroke.(Combo 5)
+    // If it's too high, forget about it
+    Functions1D::Curvature2DAngleF1D fun;
+    if(fun(stroke) > _curvatureThreshold)
+      return;
+
+    Functions0D::VertexOrientation2DF0D ori_fun;
+    Functions0D::Curvature2DAngleF0D curv_fun;
+    Functions1D::Normal2DF1D norm_fun;
+    Interface0DIterator it=stroke.verticesBegin();
+    StrokeVertex* sv;
+    while (!it.isEnd())
+      {
+	Vec2f ntmp = ori_fun(it);
+	Vec2f n(ntmp.y(), -ntmp.x());
+	Vec2f strokeN(norm_fun(stroke));
+	if(n*strokeN < 0)
+	  { 
+	    n[0] = -n[0];
+	    n[1] = -n[1];
+	  }
+	sv = dynamic_cast<StrokeVertex*>(&(*it));
+	float u=sv->u();
+	float t = 4.f*(0.25f - (u-0.5)*(u-0.5));
+	float curvature_coeff = (M_PI-curv_fun(it))/M_PI;
+	Vec2d newPoint(sv->x()+curvature_coeff*t*_amount*n.x(), sv->y()+curvature_coeff*t*_amount*n.y());
+	sv->setPoint(newPoint[0], newPoint[1]);
+	++it;
+      }
+  }
+
+  class CurvePiece
+  {
+  public:
+    StrokeInternal::StrokeVertexIterator _begin;
+    StrokeInternal::StrokeVertexIterator _last;
+    Vec2d                   A;
+    Vec2d                   B;
+    int size;
+    float _error;
+
+    CurvePiece(StrokeInternal::StrokeVertexIterator b, StrokeInternal::StrokeVertexIterator l, int iSize)
+    {
+      _begin = b;
+      _last = l;
+      A = Vec2d((_begin)->x(),(_begin)->y());
+      B = Vec2d((_last)->x(),(_last)->y());
+      size = iSize;
+    }
+
+    float error() 
+    {
+      float maxE = 0.f;
+      for(StrokeInternal::StrokeVertexIterator it=_begin;
+	  it!=_last;
+	  ++it)
+	{
+	  Vec2d P(it->x(), it->y());
+	  float d = GeomUtils::distPointSegment(P,A,B);
+	  if(d > maxE)
+	    maxE = d;
+	}
+      _error = maxE;
+      return maxE;
+    }
+    //! Subdivides the curve into two pieces.
+    //  The first piece is this same object (modified)
+    // the second piece is returned by the method
+    CurvePiece * subdivide()
+    {
+      StrokeInternal::StrokeVertexIterator it=_begin;
+      int actualSize = 1;
+      for(int i=0; i<size/2; ++i)
+	{
+	  ++it;
+	  ++actualSize;
+	}
+      CurvePiece * second = new CurvePiece(it, _last, size-actualSize+1);
+      size = actualSize;
+      _last = it;
+      B = Vec2d((_last)->x(), (_last)->y());
+      return second;
+    }
+  };
+
+  void PolygonalizationShader::shade(Stroke& stroke) const
+  {
+    vector<CurvePiece*> _pieces;
+    vector<CurvePiece*> _results;
+    vector<CurvePiece*>::iterator cp,cpend;
+
+    // Compute first approx:
+    StrokeInternal::StrokeVertexIterator a=stroke.strokeVerticesBegin();
+    StrokeInternal::StrokeVertexIterator b=stroke.strokeVerticesEnd();--b;
+    int size = stroke.strokeVerticesSize();
+
+    CurvePiece * piece = new CurvePiece(a,b,size);
+    _pieces.push_back(piece);
+  
+    while(!_pieces.empty())
+      {
+	piece = _pieces.back();_pieces.pop_back();
+	if(piece->error() > _error)
+	  {
+	    CurvePiece * second = piece->subdivide();
+	    _pieces.push_back(second);
+	    _pieces.push_back(piece);
+	  }
+	else
+	  {
+	    _results.push_back(piece);
+	  }
+      }
+
+    // actually modify the geometry for each piece:
+    for(cp=_results.begin(), cpend=_results.end();
+	cp!=cpend;
+	++cp)
+      {
+	a = (*cp)->_begin;
+	b = (*cp)->_last;
+	Vec2d u = (*cp)->B-(*cp)->A;
+	Vec2d n(u[1], -u[0]);n.normalize();
+	//Vec2d n(0,0);
+	float offset = ((*cp)->_error);
+	StrokeInternal::StrokeVertexIterator v,vlast;
+	for(v=a;
+	    v!=b;
+	    ++v)
+	  {
+	    v->setPoint((*cp)->A.x()+v->u()*u.x()+n.x()*offset, (*cp)->A.y()+v->u()*u.y()+n.y()*offset);
+	  }
+	//    u.normalize();
+	//    (*a)->setPoint((*a)->x()-u.x()*10, (*a)->y()-u.y()*10);
+      }
+
+    // delete stuff
+    for(cp=_results.begin(), cpend=_results.end();
+	cp!=cpend;
+	++cp)
+      {
+	delete (*cp);
+      }
+    _results.clear();
+  }
+
+  void GuidingLinesShader::shade(Stroke& stroke) const
+  {
+    Functions1D::Normal2DF1D norm_fun;
+    StrokeInternal::StrokeVertexIterator a=stroke.strokeVerticesBegin();
+    StrokeInternal::StrokeVertexIterator b=stroke.strokeVerticesEnd();--b;
+    int size = stroke.strokeVerticesSize();
+    CurvePiece piece(a,b,size);
+
+    Vec2d u = piece.B-piece.A;
+    Vec2f n(u[1], -u[0]);n.normalize();
+    Vec2f strokeN(norm_fun(stroke));
+    if(n*strokeN < 0)
+      {
+	n[0] = -n[0];
+	n[1] = -n[1];
+      }
+    float offset = (piece.error())/2.f*_offset;
+    StrokeInternal::StrokeVertexIterator v=a,vend=stroke.strokeVerticesEnd();
+    for(;
+	v!=vend;
+	++v)
+      {
+	v->setPoint(piece.A.x()+v->u()*u.x()+n.x()*offset, piece.A.y()+v->u()*u.y()+n.y()*offset);
+      }
+  }
+
+  /////////////////////////////////////////
+  //
+  //  Tip Remover
+  //
+  /////////////////////////////////////////
+
+
+  TipRemoverShader::TipRemoverShader(real tipLength)
+    : StrokeShader()
+  {
+    _tipLength = tipLength;
+  }
+
+  void 
+  TipRemoverShader::shade(Stroke& stroke) const 
+  {
+    int originalSize = stroke.strokeVerticesSize();
+
+    if(originalSize<4)
+      return;
+
+    StrokeInternal::StrokeVertexIterator v, vend;
+    vector<StrokeVertex*> verticesToRemove;
+    vector<StrokeAttribute> oldAttributes;
+    v=stroke.strokeVerticesBegin(); vend=stroke.strokeVerticesEnd();
+    for(;
+	v!=vend;
+	++v)
+      { 
+	if ((v->curvilinearAbscissa()<_tipLength) ||
+	    (v->strokeLength()-v->curvilinearAbscissa()<_tipLength))
+	  { 
+	    verticesToRemove.push_back(&(*v));
+	  }
+	oldAttributes.push_back(v->attribute());
+      } 
+
+    if(originalSize-verticesToRemove.size() < 2)
+      return;
+
+    vector<StrokeVertex*>::iterator sv=verticesToRemove.begin(), svend=verticesToRemove.end();
+    for(;
+	sv!=svend;
+	++sv)
+      {
+	stroke.RemoveVertex((*sv));
+      }
+
+    // Resample so that our new stroke have the same 
+    // number of vertices than before
+    stroke.Resample(originalSize);
+  
+    if((int)stroke.strokeVerticesSize() != originalSize) //soc
+      cerr << "Warning: resampling problem" << endl;
+
+    // assign old attributes to new stroke vertices:
+    v=stroke.strokeVerticesBegin(); vend=stroke.strokeVerticesEnd();
+    vector<StrokeAttribute>::iterator a=oldAttributes.begin(), aend=oldAttributes.end();
+    //cout << "-----------------------------------------------" << endl;
+    for(;(v!=vend)&&(a!=aend);++v,++a)
+      {
+	v->setAttribute(*a);
+	//cout << "thickness = " << (*a).getThickness()[0] << "-" << (*a).getThickness()[1] << endl;
+      }
+    // we're done!
+  }
+
+  void streamShader::shade(Stroke& stroke) const{
+    cout << stroke << endl;
+  } 
+  void fstreamShader::shade(Stroke& stroke) const{
+    _stream << stroke << endl;
+  } 
+
+} // end of namespace StrokeShaders
+
diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
new file mode 100755
index 00000000000..f68971a3966
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
@@ -0,0 +1,791 @@
+//
+//  Filename         : BasicStrokeShaders.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class gathering basic stroke shaders
+//  Date of creation : 17/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  BASIC_STROKE_SHADERS_H
+# define BASIC_STROKE_SHADERS_H
+
+# include "Stroke.h"
+# include "../geometry/Geom.h"
+# include "../geometry/Bezier.h"
+# include "StrokeShader.h"
+# include <fstream>
+
+using namespace std;
+using namespace Geometry;
+
+namespace StrokeShaders {
+
+  //
+  //  Thickness modifiers
+  //
+  //////////////////////////////////////////////////////
+  /*! [ Thickness Shader ].
+   *  Assigns an absolute constant thickness to every
+   *  vertices of the Stroke.
+   */
+  class LIB_STROKE_EXPORT ConstantThicknessShader : public StrokeShader
+  {
+  public:
+    /*! Builds the shader.
+     *  \param thickness
+     *    The thickness that must be assigned
+     *    to the stroke.
+     */
+    ConstantThicknessShader(float thickness) : StrokeShader() {
+      _thickness = thickness;
+    }
+    /*! Destructor. */
+    virtual ~ConstantThicknessShader() {}
+    /*! Returns the string "ConstantThicknessShader".*/
+    virtual string getName() const {
+      return "ConstantThicknessShader";
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+    float _thickness;
+  };
+
+  /* [ Thickness Shader ].
+   *  Assigns an absolute constant external thickness to every
+   *  vertices of the Stroke. The external thickness of a point
+   *  is its thickness from the point to the strip border
+   *  in the direction pointing outside the object the
+   *  Stroke delimitates.
+   */
+  class LIB_STROKE_EXPORT ConstantExternThicknessShader : public StrokeShader
+  {
+  public:
+
+    ConstantExternThicknessShader(float thickness) : StrokeShader() {
+      _thickness = thickness;
+    }
+
+    virtual ~ConstantExternThicknessShader() {}
+
+    virtual string getName() const {
+      return "ConstantExternThicknessShader";
+    }
+
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+
+    float _thickness;
+  };
+
+  /*! [ Thickness Shader ].
+   *  Assigns thicknesses values such as the thickness
+   *  increases from a thickness value A to a thickness value B
+   *  between the first vertex to the midpoint vertex and
+   *  then decreases from B to a A between this midpoint vertex
+   *  and the last vertex.
+   *  The thickness is linearly interpolated from A to B.
+   */
+  class LIB_STROKE_EXPORT IncreasingThicknessShader : public StrokeShader
+  {
+  public:
+    /*! Builds the shader.
+     *  \param iThicknessMin
+     *    The first thickness value.
+     *  \param iThicknessMax
+     *    The second thickness value.
+     */
+    IncreasingThicknessShader(float iThicknessMin, float iThicknessMax)
+      : StrokeShader()
+    {
+      _ThicknessMin = iThicknessMin;
+      _ThicknessMax = iThicknessMax;
+    }
+    /*! Destructor.*/
+    virtual ~IncreasingThicknessShader() {}
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+
+    float _ThicknessMin;
+    float _ThicknessMax;
+  };
+
+  /*! [ Thickness shader ].
+   *  Same as previous but 
+   *  here we allow the user to control the ratio thickness/length so that 
+   *  we don't get fat short lines
+   */
+  class LIB_STROKE_EXPORT ConstrainedIncreasingThicknessShader : public StrokeShader
+  {
+  private:
+    float _ThicknessMin;
+    float _ThicknessMax;
+    float _ratio;
+  public:
+    /*! Builds the shader.
+     *  \param iThicknessMin
+     *    The first thickness value.
+     *  \param iThicknessMax
+     *    The second thickness value.
+     *  \param iRatio
+     *    The ration thickness/length we don't want to
+     *    exceed.
+     */ 
+    ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio)
+      : StrokeShader()
+    {
+      _ThicknessMin = iThicknessMin;
+      _ThicknessMax = iThicknessMax;
+      _ratio = iRatio;
+    }
+    /*! Destructor.*/
+    virtual ~ConstrainedIncreasingThicknessShader() {}
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*  [ Thickness Shader ].
+   *  Modifys the thickness in a relative way
+   *  depending on its length.
+   */
+  class LIB_STROKE_EXPORT LengthDependingThicknessShader : public StrokeShader
+  {
+  private:
+    float _minThickness;
+    float _maxThickness;
+    // We divide the strokes in 4 categories:
+    // l > 300
+    // 100 < l < 300
+    // 50 < l < 100
+    // l < 50
+  public:
+    LengthDependingThicknessShader(float iMinThickness, float iMaxThickness)
+      : StrokeShader()
+    {
+      _minThickness = iMinThickness;
+      _maxThickness = iMaxThickness;
+    }
+    virtual ~LengthDependingThicknessShader() {}
+
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ Thickness Shader ].
+   *  Applys a pattern (texture) to vary thickness.
+   *  The new thicknesses are the result of the multiplication
+   *  of the pattern and the original thickness
+   */
+  class LIB_STROKE_EXPORT ThicknessVariationPatternShader : public StrokeShader
+  {
+  public:
+
+    /*! Builds the shader.
+     *  \param pattern_name
+     *    The texture file name.
+     *  \param iMinThickness
+     *    The minimum thickness we don't want to exceed.
+     *  \param iMaxThickness
+     *    The maximum thickness we don't want to exceed.
+     *  \param stretch
+     *    Tells whether the pattern texture must
+     *    be stretched or repeted to fit the stroke.
+     */
+    ThicknessVariationPatternShader(const string pattern_name,
+				    float iMinThickness = 1.f,
+				    float iMaxThickness = 5.f,
+				    bool stretch = true);
+    /*! Destructor.*/
+    virtual ~ThicknessVariationPatternShader()
+    {
+      if(0 != _aThickness)
+	{
+	  delete [] _aThickness;
+	  _aThickness = 0;
+	}
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+
+    float*	_aThickness; // array of thickness values, in % of the max (i.e comprised between 0 and 1)
+    unsigned	_size;
+    float	_minThickness;
+    float	_maxThickness;
+    bool	_stretch;
+  };
+
+  /*!  [ Thickness Shader ].
+   *   Adds some noise to the stroke thickness.
+   *   \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly
+   */
+  class LIB_STROKE_EXPORT ThicknessNoiseShader : public StrokeShader
+  {
+  private:
+    float _amplitude;
+    float _scale;
+  public:
+    ThicknessNoiseShader();
+    /*! Builds a Thickness Noise Shader
+     *    \param iAmplitude
+     *      The amplitude of the noise signal
+     *    \param iPeriod
+     *      The period of the noise signal
+     */
+    ThicknessNoiseShader(float iAmplitude, float iPeriod);
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+
+  //
+  //  Color shaders
+  //
+  /////////////////////////////////////////////////////////
+  /*!  [ Color Shader ].
+   *   Assigns a constant color to every vertices of the Stroke.
+   */
+  class LIB_STROKE_EXPORT ConstantColorShader : public StrokeShader
+  {
+  public:
+    /*! Builds the shader from a user-specified color.
+     *  \param iR
+     *    The red component
+     *  \param iG
+     *    The green component
+     *  \param iB
+     *    The blue component
+     *  \param iAlpha
+     *    The alpha value
+     */
+    ConstantColorShader(float iR, float iG, float iB, float iAlpha=1.f)
+      : StrokeShader()
+    {
+      _color[0] = iR;
+      _color[1] = iG;
+      _color[2] = iB;
+      _color[3] = iAlpha;
+    }
+
+    virtual string getName() const {
+      return "ConstantColorShader";
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+
+    float _color[4];
+  };
+
+  /*!  [ Color Shader ].
+   *   Assigns a varying color to the stroke.
+   *   The user specifies 2 colors A and B. The stroke
+   *   color will change linearly from A to B between the
+   *   first and the last vertex.
+   */
+  class LIB_STROKE_EXPORT IncreasingColorShader : public StrokeShader
+  {
+  private:
+    float _colorMin[4];
+    float _colorMax[4];
+  public:
+    /*! Builds the shader from 2 user-specified colors.
+     *  \param iRm
+     *    The first color red component
+     *  \param iGm
+     *    The first color green component
+     *  \param iBm
+     *    The first color blue component
+     *  \param iAlpham
+     *    The first color alpha value
+     *  \param iRM
+     *    The second color red component
+     *  \param iGM
+     *    The second color green component
+     *  \param iBM
+     *    The second color blue component
+     *  \param iAlphaM
+     *    The second color alpha value
+     */
+    IncreasingColorShader(float iRm, float iGm, float iBm, float iAlpham, 
+				float iRM, float iGM, float iBM, float iAlphaM)
+      : StrokeShader() 
+    {
+      _colorMin[0] = iRm;
+      _colorMin[1] = iGm;
+      _colorMin[2] = iBm;
+      _colorMin[3] = iAlpham;
+
+      _colorMax[0] = iRM;
+      _colorMax[1] = iGM;
+      _colorMax[2] = iBM;
+      _colorMax[3] = iAlphaM;
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ Color Shader ].
+   *  Applys a pattern to vary original color.
+   *  The new color is the result of the multiplication
+   *  of the pattern and the original color
+   */
+  class LIB_STROKE_EXPORT ColorVariationPatternShader : public StrokeShader
+  {
+  public:
+    /*! Builds the shader from the pattern texture file name.
+     *  \param pattern_name
+     *    The file name of the texture file to use as pattern
+     *  \param stretch
+     *    Tells whether the texture must be strecthed or repeted
+     *    to fit the stroke.
+     */
+    ColorVariationPatternShader(const string pattern_name, bool stretch = true);
+    /*! Destructor */
+    virtual ~ColorVariationPatternShader()
+    {
+      if(0 != _aVariation)
+	{
+	  delete [] _aVariation;
+	  _aVariation = 0;
+	}
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+
+  private:
+
+    float*	_aVariation; // array of coef values, in % of the max (i.e comprised between 0 and 1)
+    unsigned	_size;
+    bool	_stretch;
+  };
+
+  /* [ Color Shader ].
+   *  Assigns a color to the stroke depending
+   *  on the material of the shape to which ot belongs
+   *  to. (Disney shader)
+   */
+  class LIB_STROKE_EXPORT MaterialColorShader : public StrokeShader
+  {
+  private:
+    float _coefficient;
+  public:
+    MaterialColorShader(float coeff=1.f)
+      : StrokeShader()
+    {_coefficient=coeff;}
+
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  class LIB_STROKE_EXPORT CalligraphicColorShader : public StrokeShader
+  {
+  private:
+    int _textureId;
+    Vec2d _orientation;
+  public:
+    CalligraphicColorShader(
+			    const Vec2d &iOrientation)
+      : StrokeShader()
+    { 
+      _orientation=iOrientation;
+      _orientation.normalize();
+    } 
+    virtual void shade(Stroke& stroke) const;
+
+  };
+
+  /*! [ Color Shader ].
+   *  Shader to add noise to the stroke colors.
+   */ 
+  class LIB_STROKE_EXPORT ColorNoiseShader : public StrokeShader
+  {
+  private:
+    float _amplitude; 
+    float _scale;     
+
+  public:
+    ColorNoiseShader();
+    /*! Builds a Color Noise Shader
+     *    \param iAmplitude
+     *      The amplitude of the noise signal
+     *    \param iPeriod
+     *      The period of the noise signal
+     */
+    ColorNoiseShader(float iAmplitude, float iPeriod);
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  //
+  //  Texture Shaders
+  //
+  ///////////////////////////////////////////////////////////////////////////////
+  /*! [ Texture Shader ].
+   *  Assigns a texture to the stroke in order to simulate
+   *  its marks system. This shader takes as input an integer value
+   *  telling which texture and blending mode to use among a set of
+   *  predefined textures.
+   *  Here are the different presets:
+   *  0) -> /brushes/charcoalAlpha.bmp, HUMID_MEDIUM
+   *  1) -> /brushes/washbrushAlpha.bmp, HUMID_MEDIUM
+   *  2) -> /brushes/oil.bmp, HUMID_MEDIUM
+   *  3) -> /brushes/oilnoblend.bmp, HUMID_MEDIUM
+   *  4) -> /brushes/charcoalAlpha.bmp, DRY_MEDIUM
+   *  5) -> /brushes/washbrushAlpha.bmp, DRY_MEDIUM
+   *  6) -> /brushes/opaqueDryBrushAlpha.bmp, OPAQUE_MEDIUM
+   *  7) -> /brushes/opaqueBrushAlpha.bmp, Stroke::OPAQUE_MEDIUM
+   *  Any other value will lead to the following preset:
+   *  default) -> /brushes/smoothAlpha.bmp, OPAQUE_MEDIUM.
+   */
+  class LIB_STROKE_EXPORT TextureAssignerShader : public StrokeShader // FIXME
+  {
+  private:
+    int _textureId;
+  public:
+    /*! Builds the shader.
+     *  \param id
+     *    The number of the preset to use.
+     */
+    TextureAssignerShader(int id)
+      : StrokeShader()
+    {
+      _textureId = id;
+    }
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  
+  };
+  /*! [ Texture Shader ].
+   *  Assigns a texture and a blending mode to the stroke
+   *  in order to simulate its marks system.
+   */
+  class LIB_STROKE_EXPORT StrokeTextureShader : public StrokeShader
+  {
+  private:
+    string _texturePath;
+    Stroke::MediumType _mediumType;
+    bool _tips; // 0 or 1
+    
+  public:
+    /*! Builds the shader from the texture file name and the blending mode to use.
+     *  \param textureFile
+     *    The the texture file name.
+     *    \attention The textures must be placed in the $FREESTYLE_DIR/data/textures/brushes
+     *    directory.
+     *  \param mediumType
+     *    The medium type and therefore, the blending mode that must
+     *    be used for the rendering of this stroke.
+     *  \param iTips
+     *    Tells whether the texture includes tips or not.
+     *    If it is the case, the texture image must respect the following
+     *    format:
+     *    \verbatim
+     *     __________
+     *    |          |
+     *    |    A     |
+     *    |__________|
+     *    |     |    |
+     *    |  B  | C  |
+     *    |_____|____|
+     * 
+     *    \endverbatim
+     *    - A : The stroke's corpus texture
+     *    - B : The stroke's left extremity texture
+     *    - C : The stroke's right extremity texture
+     */
+    StrokeTextureShader(const string textureFile, Stroke::MediumType mediumType = Stroke::OPAQUE_MEDIUM, bool iTips = false)
+      : StrokeShader()
+    {
+      _texturePath = textureFile;
+      _mediumType = mediumType;
+      _tips = iTips;
+    }
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  
+  };
+
+
+  //
+  //  Geometry Shaders
+  //
+  ///////////////////////////////////////////////////////////////////////////////
+  /*! [ Geometry Shader ].
+   *  Stretches the stroke at its two extremities and following the
+   *  respective directions: v(1)v(0) and v(n-1)v(n).
+   */
+  class LIB_STROKE_EXPORT BackboneStretcherShader : public StrokeShader
+  {
+  private:
+    float _amount; 
+  public:
+    /*! Builds the shader.
+     *  \param iAmount
+     *    The stretching amount value.
+     */
+    BackboneStretcherShader(float iAmount=2.f)
+      : StrokeShader()
+    {
+      _amount = iAmount;
+    }
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ Geometry Shader. ]
+   *  Resamples the stroke.
+   *  @see Stroke::Resample(float).
+   */
+  class LIB_STROKE_EXPORT SamplingShader: public StrokeShader
+  {
+  private:
+    float _sampling;
+  public:
+    /*! Builds the shader.
+     *  \param sampling
+     *    The sampling to use for the
+     *    stroke resampling
+     */
+    SamplingShader(float  sampling)
+      : StrokeShader()
+    {
+      _sampling = sampling;
+    }
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+
+  class LIB_STROKE_EXPORT ExternalContourStretcherShader : public StrokeShader
+  {
+  private:
+    float _amount; 
+  public:
+    ExternalContourStretcherShader(float iAmount=2.f)
+      : StrokeShader()
+    {
+      _amount = iAmount;
+    }
+
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  // B-Spline stroke shader
+  class LIB_STROKE_EXPORT BSplineShader: public StrokeShader
+  { 
+  public:
+    BSplineShader()
+      : StrokeShader()
+    {}
+
+    virtual void shade(Stroke& stroke) const;
+  };
+
+
+  // Bezier curve stroke shader
+  /*! [ Geometry Shader ].
+   *  Transforms the stroke backbone geometry
+   *  so that it corresponds to a Bezier Curve
+   *  approximation of the original backbone geometry.
+   *  @see \htmlonly <a href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
+   */
+  class LIB_STROKE_EXPORT BezierCurveShader : public StrokeShader
+  { 
+  private:
+    float _error;
+  public:
+    /*! Builds the shader.
+     *  \param error
+     *    The error we're allowing for the approximation.
+     *    This error is the max distance allowed between
+     *    the new curve and the original geometry.
+     */
+    BezierCurveShader(float error = 4.0)
+      : StrokeShader()
+    {_error=error;}
+
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /* Shader to inflate the curves. It keeps the extreme
+   *  points positions and moves the other ones along 
+   *  the 2D normal. The displacement value is proportional
+   *  to the 2d curvature at the considered point (the higher 
+   *  the curvature, the smaller the displacement) and to a value 
+   *  specified by the user.
+   */
+  class LIB_STROKE_EXPORT InflateShader : public StrokeShader
+  {
+  private:
+    float _amount; 
+    float _curvatureThreshold;
+  public:
+    /*! Builds an inflate shader
+     *    \param iAmount
+     *      A multiplicative coefficient that 
+     *      acts on the amount and direction of displacement
+     *    \param iThreshold
+     *      The curves having a 2d curvature > iThreshold
+     *      at one of their points is not inflated 
+     */
+    InflateShader(float iAmount,float iThreshold)
+      : StrokeShader()
+    {
+      _amount = iAmount;
+      _curvatureThreshold = iThreshold;
+    }
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ Geometry Shader ].
+   *  Shader to modify the Stroke geometry so that 
+   *  it looks more "polygonal".
+   *  The basic idea is to start from the
+   *  minimal stroke approximation consisting in
+   *  a line joining the first vertex to the last one and
+   *  to subdivide using the original stroke vertices
+   *  until a certain error is reached.
+   */
+  class LIB_STROKE_EXPORT PolygonalizationShader : public StrokeShader
+  {
+  private:
+    float _error;
+  public:
+    /*! Builds the shader.
+     *  \param iError
+     *    The error we want our polygonal approximation
+     *    to have with respect to the original geometry.
+     *    The smaller, the closer the new stroke to
+     *    the orinal one.
+     *    This error corresponds to the maximum distance
+     *    between the new stroke and the old one.
+     */
+    PolygonalizationShader(float iError) : StrokeShader() 
+    {_error = iError;}
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+
+  /*! [ Geometry Shader ].
+   *  Shader to modify the Stroke geometry so that 
+   *  it corresponds to its main direction line.
+   *  This shader must be used together with the 
+   *  splitting operator using the curvature criterion.
+   *  Indeed, the precision of the approximation
+   *  will depend on the size of the stroke's pieces.
+   *  The bigger the pieces, the rougher the approximation.
+   */
+  class LIB_STROKE_EXPORT GuidingLinesShader : public StrokeShader
+  {
+  private:
+    float _offset;
+  public:
+    /*! Builds a Guiding Lines shader
+     *    \param iOffset
+     *      The line that replaces the stroke
+     *      is initially in the middle 
+     *      of the initial stroke "bbox".
+     *      iOffset is the value of the displacement 
+     *      which is applied to this line along its 
+     *      normal.
+     */
+    GuidingLinesShader(float iOffset) : StrokeShader()
+    {_offset = iOffset;}
+    /*! The shading method */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ Geometry Shader ].
+   *  Removes the stroke's extremities.
+   */
+  class LIB_STROKE_EXPORT TipRemoverShader : public StrokeShader 
+  {
+  public:
+    /*! Builds the shader.
+     *  \param tipLength
+     *    The length of the piece of stroke
+     *    we want to remove at each extremity.
+     */
+    TipRemoverShader (real tipLength);
+    /*! Destructor. */
+    virtual ~TipRemoverShader () {}
+    /*! The shading method */
+    virtual void shade(Stroke &stroke) const;
+
+  protected:
+
+    real _tipLength; 
+  };
+
+  /*! [ output Shader ].
+   *  streams the Stroke
+   */
+  class LIB_STROKE_EXPORT streamShader : public StrokeShader
+  {
+  public:
+    /*! Destructor. */
+    virtual ~streamShader() {}
+    /*! Returns the string "streamShader".*/
+    virtual string getName() const {
+      return "streamShader";
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+
+  /*! [ output Shader ].
+   *  streams the Stroke in a file
+   */
+  class LIB_STROKE_EXPORT fstreamShader : public StrokeShader
+  {
+  protected:
+    mutable ofstream _stream;
+  public:
+    /*! Builds the shader from the output file name */
+    fstreamShader(const char *iFileName) : StrokeShader(){
+      _stream .open(iFileName);
+      if(!_stream.is_open()){
+        cout << "couldn't open file " << iFileName << endl;
+      }
+    }
+    /*! Destructor. */
+    virtual ~fstreamShader() {_stream.close();}
+    /*! Returns the string "fstreamShader".*/
+    virtual string getName() const {
+      return "fstreamShader";
+    }
+    /*! The shading method. */
+    virtual void shade(Stroke& stroke) const;
+  };
+} // end of namespace StrokeShaders
+
+#endif // BASIC_STROKE_SHADERS_H
diff --git a/source/blender/freestyle/intern/stroke/Canvas.cpp b/source/blender/freestyle/intern/stroke/Canvas.cpp
new file mode 100755
index 00000000000..bdca8f968fe
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Canvas.cpp
@@ -0,0 +1,463 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <vector>
+#include "../system/FreestyleConfig.h"
+#include "StrokeRenderer.h"
+#include "../system/TimeStamp.h"
+#include "../system/PseudoNoise.h"
+#include "Canvas.h"
+#include "../image/Image.h"
+#include "../image/GaussianFilter.h"
+#include "../image/ImagePyramid.h"
+#include "../view_map/SteerableViewMap.h"
+#include "StyleModule.h"
+
+//soc #include <qimage.h>
+//soc #include <QString>
+#include <sstream>	
+
+extern "C" {
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+#include "intern/IMB_bmp.h"
+}
+
+using namespace std;
+
+LIB_STROKE_EXPORT
+Canvas * Canvas::_pInstance = 0;
+
+LIB_STROKE_EXPORT
+const char * Canvas::_MapsPath = 0;
+
+using namespace std;
+
+Canvas::Canvas()
+{
+  _SelectedFEdge = 0;
+  _pInstance = this;
+  PseudoNoise::init(42);
+  _paperTextureIndex = 0;
+  _Renderer = 0;
+  _drawPaper = true;
+  _current_sm = NULL;
+  _steerableViewMap = new SteerableViewMap(NB_STEERABLE_VIEWMAP-1);
+}
+
+Canvas::Canvas(const Canvas& iBrother)
+{
+  _SelectedFEdge = iBrother._SelectedFEdge;
+  _pInstance = this;
+  PseudoNoise::init(42);
+  _paperTextureIndex = iBrother._paperTextureIndex;
+  _Renderer = iBrother._Renderer;
+  _drawPaper = iBrother._drawPaper;
+  _current_sm = iBrother._current_sm;
+  _steerableViewMap = new SteerableViewMap(*(iBrother._steerableViewMap));
+  
+}
+
+Canvas::~Canvas()
+{
+  _pInstance = 0;
+
+  Clear();
+  if(_Renderer)
+  {
+    delete _Renderer;
+    _Renderer = 0;
+  }
+  // FIXME: think about an easy control 
+  // for the maps memory management...
+  if(!_maps.empty()){
+    for(mapsMap::iterator m=_maps.begin(), mend=_maps.end();
+    m!=mend;
+    ++m){
+      delete ((*m).second);
+    }
+    _maps.clear();
+  }
+  if(_steerableViewMap)
+    delete _steerableViewMap;
+}
+
+void Canvas::preDraw() {}
+
+void Canvas::Draw()
+{
+  if(_StyleModules.empty())
+    return;
+  preDraw();
+  TimeStamp *timestamp = TimeStamp::instance();
+
+  for(unsigned i = 0; i < _StyleModules.size(); i++) {
+    _current_sm = _StyleModules[i];
+    if (!_StyleModules[i]->getModified())
+    {
+      if (_StyleModules[i]->getDrawable() && _Layers[i])
+	_Layers[i]->Render(_Renderer);
+      continue;
+    }
+    if (i < _Layers.size() && _Layers[i])
+      delete _Layers[i];
+
+    _Layers[i] = _StyleModules[i]->execute();
+
+    if (_StyleModules[i]->getDrawable() && _Layers[i])
+      _Layers[i]->Render(_Renderer);
+
+    timestamp->increment();
+  }
+  postDraw();
+}
+
+void Canvas::postDraw()
+{
+  update();
+}
+
+
+void Canvas::Clear()
+{
+  if(!_Layers.empty()) {
+    for (deque<StrokeLayer*>::iterator sl=_Layers.begin(), slend=_Layers.end();
+	 sl != slend;
+	 ++sl)
+      if (*sl)
+	delete (*sl);
+    _Layers.clear();  
+  }
+
+  if(!_StyleModules.empty()) {
+    for (deque<StyleModule*>::iterator s=_StyleModules.begin(), send=_StyleModules.end();
+	 s != send;
+	 ++s)
+      if (*s)
+	delete (*s);
+    _StyleModules.clear();
+  }
+  if(_steerableViewMap)
+    _steerableViewMap->Reset();
+}
+
+void Canvas::Erase()
+{
+  if(!_Layers.empty())
+  {
+    for (deque<StrokeLayer*>::iterator sl=_Layers.begin(), slend=_Layers.end();
+	 sl != slend;
+	 ++sl)
+      if (*sl)
+	(*sl)->clear();
+  }
+  if(_steerableViewMap)
+    _steerableViewMap->Reset();
+  update();
+}
+
+void Canvas::InsertStyleModule(unsigned index, StyleModule *iStyleModule) {
+  unsigned size = _StyleModules.size();
+  StrokeLayer* layer = new StrokeLayer();
+  if((_StyleModules.empty()) || (index == size)) {
+    _StyleModules.push_back(iStyleModule);
+    _Layers.push_back(layer);
+    return;
+  }
+	_StyleModules.insert(_StyleModules.begin() + index, iStyleModule);
+  _Layers.insert(_Layers.begin()+index, layer);
+}
+
+void Canvas::RemoveStyleModule(unsigned index)
+{
+  unsigned i=0;
+  if (!_StyleModules.empty())
+    {
+      for(deque<StyleModule*>::iterator s=_StyleModules.begin(), send=_StyleModules.end();
+	  s!=send;
+	  ++s)
+	{
+	  if(i == index)
+	    { 
+	      // remove shader
+	      if (*s)
+		delete *s;
+	      _StyleModules.erase(s);
+	      break;
+	    } 
+	  ++i;
+	}
+    }
+  i=0;
+  if(!_Layers.empty())
+  {
+    for(deque<StrokeLayer*>::iterator sl=_Layers.begin(), slend=_Layers.end();
+    sl!=slend;
+    ++sl)
+    {
+      if(i == index)
+      { 
+        // remove layer
+	if (*sl)
+	  delete *sl;
+        _Layers.erase(sl);
+        break;
+      } 
+      ++i;
+    }
+  }
+}
+
+
+void Canvas::SwapStyleModules(unsigned i1, unsigned i2)
+{
+  StyleModule* tmp;
+  tmp = _StyleModules[i1];
+  _StyleModules[i1] = _StyleModules[i2];
+  _StyleModules[i2] = tmp;
+
+  StrokeLayer* tmp2;
+  tmp2 = _Layers[i1];
+  _Layers[i1] = _Layers[i2];
+  _Layers[i2] = tmp2;
+}
+
+void Canvas::ReplaceStyleModule(unsigned index, StyleModule *iStyleModule)
+{
+  unsigned i=0;
+  for(deque<StyleModule*>::iterator s=_StyleModules.begin(), send=_StyleModules.end();
+      s != send;
+      ++s)
+    {
+      if(i == index)
+	{
+	  if (*s)
+	    delete *s;
+	  *s = iStyleModule;
+	  break;
+	}
+      ++i;
+    }
+}
+
+void Canvas::setVisible(unsigned index, bool iVisible) {
+  _StyleModules[index]->setDisplayed(iVisible);
+}
+ 
+void Canvas::setModified(unsigned index, bool iMod)
+{
+  _StyleModules[index]->setModified(iMod);
+}
+
+void Canvas::resetModified(bool iMod/* =false */)
+{
+  unsigned size = _StyleModules.size();
+  for(unsigned i = 0; i < size; ++i)
+    setModified(i,iMod);
+}
+
+void Canvas::causalStyleModules(vector<unsigned>& vec, unsigned index) {
+  unsigned size = _StyleModules.size();
+
+  for(unsigned i = index; i < size; ++i)
+    if (_StyleModules[i]->getCausal())
+      vec.push_back(i);
+}
+
+void Canvas::changePaperTexture(bool increment)
+{
+  if(increment)
+    _paperTextureIndex = (_paperTextureIndex+1) % TextureManager::getPaperTexturesNumber();
+  else
+  {
+    _paperTextureIndex--;
+    if(_paperTextureIndex < 0)
+      _paperTextureIndex = TextureManager::getPaperTexturesNumber() - 1;
+  }
+}
+
+void Canvas::Render(const StrokeRenderer *iRenderer)
+{
+  for (unsigned i = 0; i < _StyleModules.size(); i++) {
+    if(!_StyleModules[i]->getDisplayed() || !_Layers[i])
+      continue;
+    _Layers[i]->Render(iRenderer);
+  }
+}
+
+void Canvas::RenderBasic(const StrokeRenderer *iRenderer)
+
+{
+  for (unsigned i = 0; i < _StyleModules.size(); i++) {
+    if(!_StyleModules[i]->getDisplayed() || !_Layers[i])
+      continue;
+    _Layers[i]->RenderBasic(iRenderer);
+  }
+}
+
+void Canvas::loadMap(const char *iFileName, const char *iMapName, unsigned int iNbLevels, float iSigma){
+  // check whether this map was already loaded:
+  if(!_maps.empty()){
+    mapsMap::iterator m = _maps.find(iMapName);
+    if(m!=_maps.end()){
+      // lazy check for size changes
+      ImagePyramid * pyramid = (*m).second;
+      if((pyramid->width() != width()) || (pyramid->height() != height())){
+        delete pyramid;
+      }else{
+        return;
+      }
+    }
+  }
+  string filePath;
+  if(_MapsPath){
+    filePath = _MapsPath;
+    filePath += iFileName;
+  }else{
+    filePath = iFileName;
+  }
+
+  //soc
+  // QImage *qimg;
+  // QImage newMap(filePath.c_str()); 
+  // if(newMap.isNull()){
+  //   cout << "Could not load image file " << filePath << endl;
+  //   return;
+  // }
+  // qimg = &newMap;
+  	ImBuf *qimg = IMB_loadiffname(filePath.c_str(), 0);;
+  	if( qimg == 0 ){
+		cout << "Could not load image file " << filePath << endl;
+    	return;	
+	}
+
+  // soc
+  //resize
+  // QImage scaledImg;
+  // if((newMap.width()!=width()) || (newMap.height()!=height())){
+  // 	  scaledImg = newMap.scaled(width(), height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+  //   qimg = &scaledImg;
+  // }
+	ImBuf *scaledImg;
+  if( ( qimg->x != width() ) || ( qimg->y != height() ) ){
+	scaledImg = IMB_dupImBuf(qimg);
+	IMB_scaleImBuf(scaledImg, width(), height());
+  }
+
+
+  // deal with color image 
+  //  if(newMap->depth() != 8){
+  //    int w = newMap->width();
+  //    int h = newMap->height();
+  //    QImage *tmp = new QImage(w, h, 8);
+  //    for(unsigned y=0;y<h;++y){
+  //      for(unsigned x=0;x<w;++x){
+  //        int c = qGray(newMap->pixel(x,y));
+  //        tmp->setPixel(x,y,c);
+  //      }
+  //    }
+  //    delete newMap;
+  //    newMap = tmp;
+  //  }
+
+  int x,y;
+  int w = qimg->x;
+  int h = qimg->y;
+int rowbytes = w*4;
+  GrayImage tmp(w,h);
+  char *pix;
+  
+  for(y=0; y<h;++y){
+    for(x=0;x<w;++x){
+		pix = (char*)qimg->rect + y*rowbytes + x*4;
+	  float c = (pix[0]*11 + pix[1]*16 + pix[2]*5)/32;
+      tmp.setPixel(x,y,c);
+    }
+  }
+
+  //  GrayImage blur(w,h);
+  //  GaussianFilter gf(4.f);
+  //  //int bound = gf.getBound();
+  //  for(y=0; y<h;++y){
+  //    for(x=0;x<w;++x){
+  //      int c = gf.getSmoothedPixel<GrayImage>(&tmp, x,y);
+  //      blur.setPixel(x,y,c);
+  //    }
+  //  }
+
+  GaussianPyramid *pyramid = new GaussianPyramid(tmp, iNbLevels, iSigma);
+  int ow = pyramid->width(0);
+  int oh = pyramid->height(0);
+  string base(iMapName); //soc
+  for(int i=0; i<pyramid->getNumberOfLevels(); ++i){
+    // save each image:
+    //    w = pyramid.width(i);
+    //    h = pyramid.height(i);
+	
+	//soc  QImage qtmp(ow, oh, QImage::Format_RGB32);
+    ImBuf *qtmp = IMB_allocImBuf(ow, oh, 32, IB_rect, 0);
+
+//int k = (1<<i);
+    for(y=0;y<oh;++y){
+      for(x=0;x<ow;++x){
+        int c = pyramid->pixel(x,y,i);//255*pyramid->pixel(x,y,i);
+        //soc qtmp.setPixel(x,y,qRgb(c,c,c));
+		pix = (char*)qtmp->rect + y*rowbytes + x*4;
+		pix[0] = pix [1] = pix[2] = c;
+      }
+    }
+    //soc qtmp.save(base+QString::number(i)+".bmp", "BMP");
+	stringstream filename;
+	filename << base;
+	filename << i << ".bmp";	
+	imb_savebmp(qtmp, const_cast<char *>(filename.str().c_str()), 0);
+	
+  }
+  //  QImage *qtmp = new QImage(w, h, 32);
+  //  for(y=0;y<h;++y){
+  //    for(x=0;x<w;++x){
+  //      int c = (int)blur.pixel(x,y);
+  //      qtmp->setPixel(x,y,qRgb(c,c,c));
+  //    }
+  //  }
+  //  delete newMap;
+  //  newMap = qtmp;
+  //
+  _maps[iMapName] = pyramid;
+  //  newMap->save("toto.bmp", "BMP");
+}
+
+float Canvas::readMapPixel(const char *iMapName, int level, int x, int y){
+  if(_maps.empty()){
+    cout << "readMapPixel warning: no map was loaded "<< endl;
+    return -1;
+  }
+  mapsMap::iterator m = _maps.find(iMapName);
+  if(m==_maps.end()){
+    cout << "readMapPixel warning: no map was loaded with the name " << iMapName << endl;
+    return -1;
+  }
+  ImagePyramid *pyramid = (*m).second;
+  if((x<0) || (x>=pyramid->width()) || (y<0) || (y>=pyramid->height()))
+    return 0;
+  
+  return pyramid->pixel(x,height()-1-y,level);
+}
diff --git a/source/blender/freestyle/intern/stroke/Canvas.h b/source/blender/freestyle/intern/stroke/Canvas.h
new file mode 100755
index 00000000000..549c6a97d55
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Canvas.h
@@ -0,0 +1,198 @@
+//
+//  Filename         : Canvas.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a canvas designed to draw style modules
+//  Date of creation : 20/10/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CANVAS_H
+# define CANVAS_H
+
+# include <deque>
+# include <vector>
+# include <map>
+# include "../system/FreestyleConfig.h"
+# include "StrokeLayer.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+
+using namespace Geometry;
+
+struct ltstr
+{
+  bool operator()(const char* s1, const char* s2) const
+  {
+    return strcmp(s1, s2) < 0;
+  }
+};
+
+class InformationMap;
+class StrokeRenderer;
+class ViewMap;
+class ViewEdge;
+class FEdge;
+class RGBImage;
+class GrayImage;
+class QImage;
+class ImagePyramid;
+class SteerableViewMap;
+class StyleModule;
+
+/*! Class to define the canvas on which strokes are drawn.
+ *  It's used to store state information about the drawing.
+ */
+class LIB_STROKE_EXPORT Canvas 
+{
+public:
+  /*! Returns a pointer on the Canvas instance */
+  static Canvas * getInstance() {return _pInstance;}
+  typedef std::map<const char*, ImagePyramid*, ltstr> mapsMap ;
+  static const int NB_STEERABLE_VIEWMAP = 5;
+protected:
+  static Canvas *_pInstance;
+  std::deque<StrokeLayer*> _Layers;
+  std::deque<StyleModule*> _StyleModules;
+  FEdge *_SelectedFEdge;
+  int _paperTextureIndex;
+  bool _drawPaper;
+  StrokeRenderer *_Renderer;
+  StyleModule* _current_sm;
+  mapsMap _maps;
+  static const char * _MapsPath;
+  SteerableViewMap *_steerableViewMap;
+  
+public:
+  /* Builds the Canvas */
+  Canvas();
+  /* Copy constructor */
+  Canvas(const Canvas& iBrother);
+  /* Destructor */
+  virtual ~Canvas();
+
+  /* operations that need to be done before a draw */
+  virtual void preDraw();
+
+  /* Draw the canvas using the current shader */
+  virtual void Draw();
+
+  /* operations that need to be done after a draw */
+  virtual void postDraw();
+
+  /* Renders the created strokes */
+  virtual void Render(const StrokeRenderer *iRenderer);
+  /* Basic Renders the created strokes */
+  virtual void RenderBasic(const StrokeRenderer *iRenderer);
+  /* Renders a stroke */
+  virtual void RenderStroke(Stroke *iStroke) = 0;
+  
+  /* init the canvas */
+  virtual void init() = 0;
+  
+  /* Clears the Canvas (shaders stack, layers stack...)*/
+  void Clear();
+
+  /* Erases the layers */
+  virtual void Erase(); 
+
+  /* Reads a pixel area from the canvas */
+  virtual void readColorPixels(int x, int y,int w, int h, RGBImage& oImage) const = 0;
+  /* Reads a depth pixel area from the canvas */
+  virtual void readDepthPixels(int x, int y,int w, int h, GrayImage& oImage) const = 0;
+
+  /* update the canvas (display) */
+  virtual void update() = 0;
+
+  /* checks whether the canvas is empty or not */
+  bool isEmpty() const {return (_Layers.empty());}
+
+  /* Maps management */
+  /*! Loads an image map. The map will be scaled 
+   *  (without preserving the ratio in order 
+   *  to fit the actual canvas size.)
+   *  The image must be a gray values image...
+   *  \param iFileName
+   *    The name of the image file
+   *  \param iMapName
+   *    The name that will be used to access
+   *    this image
+   *  \param iNbLevels
+   *    The number of levels in the map pyramid. (default = 4).
+   *    If iNbLevels == 0, the complete pyramid is built.
+   */
+  void loadMap(const char *iFileName, const char *iMapName, unsigned iNbLevels=4, float iSigma = 1.f);
+
+  /*! Reads a pixel value in a map.
+   *  Returns a value between 0 and 1.
+   *  \param iMapName
+   *    The name of the map
+   *  \param level
+   *    The level of the pyramid from which the pixel must 
+   *    be read.
+   *  \param x
+   *    The abscissa of the desired pixel specified in level0 coordinate 
+   *    system. The origin is the lower left corner.
+   *  \param y
+   *    The ordinate of the desired pixel specified in level0 coordinate 
+   *    system. The origin is the lower left corner.
+   */
+  float readMapPixel(const char *iMapName, int level, int x, int y);
+
+  /*! Sets the steerable viewmap */
+  void loadSteerableViewMap(SteerableViewMap * iSVM) {_steerableViewMap = iSVM;}
+
+  /*! Returns the steerable VM */
+  SteerableViewMap * getSteerableViewMap() {return _steerableViewMap;}
+  
+  /*! accessors */
+  inline const FEdge * selectedFEdge() const {return _SelectedFEdge;}
+  inline FEdge * selectedFEdge() {return _SelectedFEdge;}
+  virtual int width() const = 0;
+  virtual int height() const = 0;
+  inline int currentPaperTextureIndex() const {return _paperTextureIndex;}
+  virtual BBox<Vec3r> scene3DBBox() const = 0;
+  inline const StrokeRenderer * renderer() const {return _Renderer;}
+  inline StyleModule* getCurrentStyleModule() { return _current_sm; }
+  virtual bool getRecordFlag() const {return false;}
+
+  /*! modifiers */
+  inline void setSelectedFEdge(FEdge *iFEdge) {_SelectedFEdge = iFEdge;}
+  /*! inserts a shader at pos index+1 */
+  void InsertStyleModule(unsigned index, StyleModule *iStyleModule);
+  void RemoveStyleModule(unsigned index);
+  void SwapStyleModules(unsigned i1, unsigned i2);
+  void ReplaceStyleModule(unsigned index, StyleModule *iStyleModule);
+  void setVisible(unsigned index, bool iVisible) ;
+  //inline void setDensityMap(InformationMap<RGBImage>* iMap) {_DensityMap = iMap;}
+  inline void AddLayer(StrokeLayer *iLayer) {_Layers.push_back(iLayer);}
+  inline void setCurrentPaperTextureIndex(int i) {_paperTextureIndex = i;}
+  void changePaperTexture(bool increment=true) ;
+  /*! enables/disables paper texture */
+  inline void togglePaperTexture() {_drawPaper = !_drawPaper;}
+  void resetModified(bool iMod=false);
+  void causalStyleModules(std::vector<unsigned>& vec, unsigned index = 0);
+  void setModified(unsigned index, bool b);
+};
+
+#endif // CANVAS_H
diff --git a/source/blender/freestyle/intern/stroke/Chain.cpp b/source/blender/freestyle/intern/stroke/Chain.cpp
new file mode 100755
index 00000000000..3776cd58a03
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Chain.cpp
@@ -0,0 +1,126 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Chain.h"
+#include "../view_map/ViewMapIterators.h"
+#include "../view_map/ViewMapAdvancedIterators.h"
+
+void Chain::push_viewedge_back(ViewEdge *iViewEdge, bool orientation)
+{
+  ViewEdge::vertex_iterator v;
+  ViewEdge::vertex_iterator vend;
+  ViewEdge::vertex_iterator vfirst;
+  Vec3r previous, current;
+  if(true == orientation)
+  {
+    v=iViewEdge->vertices_begin();
+    vfirst = v;
+    vend=iViewEdge->vertices_end();
+  }
+  else
+  {
+    v=iViewEdge->vertices_last();
+    vfirst = v;
+    vend=iViewEdge->vertices_end();
+  }
+
+  if(!_Vertices.empty())
+  {
+    previous = _Vertices.back()->point2d();
+    if(orientation)
+      ++v;
+    else
+      --v;
+  }
+  else
+    previous = (*v)->point2d(); 
+  do{
+    current = (*v)->point2d();
+    Curve::push_vertex_back(*v);
+    //_Length += (current-previous).norm();
+    previous = current;
+    if(orientation)
+      ++v;
+    else
+      --v;
+  }while((v!=vend) && (v!=vfirst));
+
+  if(v==vfirst)
+  {
+    //Add last one:
+    current = (*v)->point2d();
+    Curve::push_vertex_back(*v);
+    //_Length += (current-previous).norm();
+  }
+} 
+
+void Chain::push_viewedge_front(ViewEdge *iViewEdge, bool orientation)
+{
+  orientation = !orientation;
+  ViewEdge::vertex_iterator v;
+  ViewEdge::vertex_iterator vend;
+  ViewEdge::vertex_iterator vfirst;
+  Vec3r previous, current;
+  if(true == orientation)
+  {
+    v=iViewEdge->vertices_begin();
+    vfirst = v;
+    vend=iViewEdge->vertices_end();
+  }
+  else
+  {
+    v=iViewEdge->vertices_last();
+    vfirst = v;
+    vend=iViewEdge->vertices_end();
+  }
+
+  if(!_Vertices.empty())
+  {
+    previous = _Vertices.front()->point2d();
+    if(orientation)
+      ++v;
+    else
+      --v;
+  }
+  else
+    previous = (*v)->point2d(); 
+  do{
+    current = (*v)->point2d();
+    Curve::push_vertex_front((*v));
+    //_Length += (current-previous).norm();
+    previous = current;
+    if(orientation)
+      ++v;
+    else
+      --v;
+  }while((v!=vend) && (v!=vfirst));
+  
+  if(v==vfirst)
+  {
+    //Add last one:
+    current = (*v)->point2d();
+    Curve::push_vertex_front(*v);
+    //_Length += (current-previous).norm();
+  }
+}
+
+
+
diff --git a/source/blender/freestyle/intern/stroke/Chain.h b/source/blender/freestyle/intern/stroke/Chain.h
new file mode 100755
index 00000000000..042437a4154
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Chain.h
@@ -0,0 +1,82 @@
+//
+//  Filename         : Chain.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a chain of viewedges.
+//  Date of creation : 09/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CHAIN_H
+# define CHAIN_H
+
+# include "../view_map/ViewMap.h"
+# include "Curve.h"
+/*! Class to represent a 1D elements issued
+ *  from the chaining process.
+ *  A Chain is the last step before the Stroke and
+ *  is used in the Splitting and Creation processes.
+ */
+class Chain : public Curve
+{
+protected:
+  // tmp
+  Id * _splittingId;
+public:
+  /*! Defult constructor. */
+  Chain() : Curve() {_splittingId=0;}
+  /*! Builds a chain from its Id. */
+  Chain(const Id& id) : Curve(id) {_splittingId=0;}
+  /*! Copy Constructor */
+  Chain(const Chain& iBrother) : Curve(iBrother) {_splittingId=iBrother._splittingId;}
+  /*! Destructor. */
+  virtual ~Chain() {
+    // only the last splitted deletes this id
+    if(_splittingId){
+      if(*_splittingId == _Id)
+        delete _splittingId;
+    }
+  }
+
+  /*! Adds a ViewEdge at the end of the chain
+   *  \param iViewEdge
+   *    The ViewEdge that must be added.
+   *  \param orientation
+   *    The orientation with which this ViewEdge
+   *    must be processed.
+   */
+  void push_viewedge_back(ViewEdge *iViewEdge, bool orientation) ;
+  /*! Adds a ViewEdge at the beginning of the chain
+   *  \param iViewEdge
+   *    The ViewEdge that must be added.
+   *  \param orientation
+   *    The orientation with which this ViewEdge
+   *    must be processed.
+   */
+  void push_viewedge_front(ViewEdge *iViewEdge, bool orientation) ;
+
+  inline void setSplittingId(Id * sid){_splittingId = sid;}
+  inline Id* getSplittingId() {return _splittingId;}
+};
+
+#endif // CHAIN_H
diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.cpp b/source/blender/freestyle/intern/stroke/ChainingIterators.cpp
new file mode 100755
index 00000000000..ede3488c546
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/ChainingIterators.cpp
@@ -0,0 +1,147 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#include "ChainingIterators.h"
+#include "../system/TimeStamp.h"
+
+ViewEdge* AdjacencyIterator::operator*() {
+  return (*_internalIterator).first;
+}
+bool AdjacencyIterator::isIncoming() const{
+  return (*_internalIterator).second;
+}
+
+void AdjacencyIterator::increment(){
+  ++_internalIterator;
+  while((!_internalIterator.isEnd()) && (!isValid((*_internalIterator).first)))
+    ++_internalIterator;
+}
+
+bool AdjacencyIterator::isValid(ViewEdge* edge){
+  if(_restrictToSelection)
+    if(edge->getTimeStamp() != TimeStamp::instance()->getTimeStamp())
+      return false;
+  if(_restrictToUnvisited)
+    if(edge->getChainingTimeStamp() > TimeStamp::instance()->getTimeStamp())
+      return false;
+    return true;
+}
+
+void ChainingIterator::increment() {
+  _increment = true;
+  ViewVertex * vertex = getVertex();
+  if(!vertex){
+    _edge = 0;
+    return;
+  }
+  AdjacencyIterator it = AdjacencyIterator(vertex, _restrictToSelection, _restrictToUnvisited);
+  if(it.isEnd())
+    _edge = 0;
+  else
+    _edge = traverse(it);
+  if(_edge == 0)
+    return;
+  if(_edge->A() == vertex)
+    _orientation = true;
+  else
+    _orientation = false;
+}
+
+void ChainingIterator::decrement() {
+  _increment = false;
+  ViewVertex * vertex = getVertex();
+  if(!vertex){
+    _edge = 0;
+    return;
+  }
+  AdjacencyIterator it = AdjacencyIterator(vertex, _restrictToSelection, _restrictToUnvisited);
+  if(it.isEnd())
+    _edge = 0;
+  else
+    _edge = traverse(it);
+  if(_edge == 0)
+    return;
+  if(_edge->B() == vertex)
+    _orientation = true;
+  else
+    _orientation = false;
+}
+
+//
+// ChainSilhouetteIterators
+//
+///////////////////////////////////////////////////////////
+
+ViewEdge * ChainSilhouetteIterator::traverse(const AdjacencyIterator& ait){
+  AdjacencyIterator it(ait);
+  ViewVertex* nextVertex = getVertex();
+  // we can't get a NULL nextVertex here, it was intercepted
+  // before
+  if(nextVertex->getNature() & Nature::T_VERTEX){
+    TVertex * tvertex = (TVertex*)nextVertex;
+    ViewEdge *mate = (tvertex)->mate(getCurrentEdge());
+    while(!it.isEnd()){
+      ViewEdge *ve = *it;
+      if(ve == mate)
+        return ve;
+      ++it;
+    }
+    return 0;
+  }
+  if(nextVertex->getNature() & Nature::NON_T_VERTEX){
+    //soc NonTVertex * nontvertex = (NonTVertex*)nextVertex;
+    ViewEdge * newEdge(0);
+    // we'll try to chain the edges by keeping the same nature...
+    // the preseance order is : SILHOUETTE, BORDER, CREASE, SUGGESTIVE, VALLEY, RIDGE
+    Nature::EdgeNature natures[6] = {Nature::SILHOUETTE, Nature::BORDER, Nature::CREASE, Nature::SUGGESTIVE_CONTOUR, Nature::VALLEY, Nature::RIDGE};
+    for(unsigned i=0; i<6; ++i){
+      if(getCurrentEdge()->getNature() & natures[i]){
+        int n = 0;
+        while(!it.isEnd()){
+          ViewEdge *ve = *it;
+          if(ve->getNature() & natures[i]){
+            ++n;
+            newEdge = ve;
+          } 
+          ++it;
+        } 
+        if(n == 1){
+          return newEdge;
+        }else{
+          return 0;
+        }   
+      } 
+    }
+  }
+  return 0;
+}
+
+ViewEdge * ChainPredicateIterator::traverse(const AdjacencyIterator& ait){
+  AdjacencyIterator it(ait);
+  // Iterates over next edges to see if one of them 
+  // respects the predicate:
+  while(!it.isEnd()) {
+    ViewEdge *ve = *it;
+    if(((*_unary_predicate)(*ve)) && ((*_binary_predicate)(*(getCurrentEdge()),*(ve))))
+        return ve;
+    ++it;
+  }
+  return 0;
+} 
diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.h b/source/blender/freestyle/intern/stroke/ChainingIterators.h
new file mode 100755
index 00000000000..1e946855dce
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/ChainingIterators.h
@@ -0,0 +1,364 @@
+//
+//  Filename         : ChainingIterators
+//  Author           : Stephane Grabli
+//  Purpose          : Chaining iterators
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#ifndef  CHAININGITERATORS_H
+# define CHAININGITERATORS_H
+
+# include <iostream>
+# include "../view_map/ViewMap.h"
+# include "../view_map/ViewMapIterators.h"
+# include "../view_map/ViewMapAdvancedIterators.h"
+# include "Predicates1D.h"
+
+//using namespace ViewEdgeInternal;
+
+//
+// Adjacency iterator used in the chaining process
+//
+///////////////////////////////////////////////////////////
+class LIB_STROKE_EXPORT AdjacencyIterator{
+protected:
+  ViewVertexInternal::orientedViewEdgeIterator _internalIterator;
+  bool _restrictToSelection;
+  bool _restrictToUnvisited;
+public:
+  AdjacencyIterator(){
+    _restrictToSelection = true;
+    _restrictToUnvisited = true;
+  }
+  AdjacencyIterator(ViewVertex *iVertex, bool iRestrictToSelection = true, bool iRestrictToUnvisited = true){
+    _restrictToSelection = iRestrictToSelection;
+    _restrictToUnvisited = iRestrictToUnvisited;
+    _internalIterator = iVertex->edgesBegin();
+    while((!_internalIterator.isEnd()) && (!isValid((*_internalIterator).first)))
+      ++_internalIterator;
+  }
+  AdjacencyIterator(const AdjacencyIterator& iBrother){
+    _internalIterator = iBrother._internalIterator;
+    _restrictToSelection = iBrother._restrictToSelection;
+    _restrictToUnvisited = iBrother._restrictToUnvisited;
+  }
+  AdjacencyIterator& operator=(const AdjacencyIterator& iBrother) {  
+    _internalIterator = iBrother._internalIterator;
+    _restrictToSelection = iBrother._restrictToSelection;
+    _restrictToUnvisited = iBrother._restrictToUnvisited;  
+    return *this;
+  } 
+  virtual ~AdjacencyIterator(){
+  }
+  
+  inline bool isEnd(){
+    return _internalIterator.isEnd();
+  }
+  inline bool isBegin(){
+    return _internalIterator.isBegin();
+  }
+  /*! Returns true if the current ViewEdge is is coming
+   *  towards the iteration vertex. False otherwise.
+   */
+  bool isIncoming() const ;
+
+  /*! Returns a *pointer* to the pointed ViewEdge. */
+  virtual ViewEdge* operator*() ;
+  virtual ViewEdge* operator->() {return operator*();}
+  virtual AdjacencyIterator& operator++() {
+    increment();
+    return *this;
+  }
+  virtual AdjacencyIterator operator++(int) {
+    AdjacencyIterator tmp(*this);
+    increment();
+    return tmp;
+  }
+  void increment();
+  
+protected:
+  bool isValid(ViewEdge* edge);
+};
+
+//
+// Base class for Chaining Iterators
+//
+///////////////////////////////////////////////////////////
+
+/*! Base class for chaining iterators.
+ *  This class is designed to be overloaded
+ *  in order to describe chaining rules.
+ *  It makes the works of chaining rules description 
+ *  easier.
+ *  The two main methods that need to overloaded are 
+ *  traverse() and init(). 
+ *  traverse() tells which ViewEdge to follow, among the adjacent ones.
+ *  If you specify restriction rules (such as "Chain only 
+ *  ViewEdges of the selection"), they will be included 
+ *  in the adjacency iterator. (i.e, the adjacent iterator 
+ *  will only stop on "valid" edges).
+ */
+class LIB_STROKE_EXPORT ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator{
+protected:
+  bool _restrictToSelection;
+  bool _restrictToUnvisited;
+  bool _increment; //true if we're currently incrementing, false when decrementing
+  
+public:
+  /*! Builds a Chaining Iterator from the first ViewEdge used for iteration
+   *  and its orientation.
+   *  \param iRestrictToSelection
+   *    Indicates whether to force the chaining to stay within
+   *    the set of selected ViewEdges or not.
+   *  \param iRestrictToUnvisited
+   *    Indicates whether a ViewEdge that has already been chained
+   *    must be ignored ot not.
+   *  \param begin
+   *    The ViewEdge from which to start the chain.
+   *  \param orientation
+   *    The direction to follow to explore the graph. If true,
+   *    the direction indicated by the first ViewEdge is used.
+   */
+  ChainingIterator(bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge* begin = 0, bool orientation = true)
+    : ViewEdgeIterator(begin, orientation) {
+    _restrictToSelection = iRestrictToSelection;
+    _restrictToUnvisited = iRestrictToUnvisited;
+    _increment = true;
+  }
+
+  /*! Copy constructor */
+  ChainingIterator(const ChainingIterator& brother)
+    : ViewEdgeIterator(brother) {
+    _restrictToSelection = brother._restrictToSelection;
+    _restrictToUnvisited = brother._restrictToUnvisited;
+    _increment = brother._increment;
+  }
+
+  /*! Returns the string "ChainingIterator" */
+  virtual string getExactTypeName() const {
+    return "ChainingIterator";
+  }
+
+  /*! Inits the iterator context.
+   *  This method is called each time 
+   *  a new chain is started.
+   *  It can be used to reset some 
+   *  history information that you 
+   *  might want to keep.  
+   */
+  virtual void init(){}
+  
+  /*! This method iterates over the potential next 
+   *  ViewEdges and returns the one that will be 
+   *  followed next.
+   *  returns the next ViewEdge to follow or 
+   *  0 when the end of the chain is reached.
+   *  \param it
+   *    The iterator over the ViewEdges adjacent to 
+   *    the end vertex of the current ViewEdge.
+   *    The Adjacency iterator reflects the restriction 
+   *    rules by only iterating over the valid ViewEdges.
+   */
+  virtual ViewEdge * traverse(const AdjacencyIterator &it){
+    cerr << "Warning: the traverse method was not defined" << endl;
+    return 0;
+  }
+  
+  /* accessors */
+  /*! Returns true if the orientation of the current ViewEdge 
+   *  corresponds to its natural orientation
+   */
+  //inline bool getOrientation() const {}
+  /*! Returns the vertex which is the next crossing */
+  inline ViewVertex * getVertex() {
+    if(_increment){
+      if(_orientation){
+        return _edge->B();
+      }else{
+        return _edge->A();
+      }  
+    }else{
+      if(_orientation){
+        return _edge->A();
+      }else{
+        return _edge->B();
+      }
+    }
+  }
+
+  /*! Returns true if the current iteration is an incrementation */
+  inline bool isIncrementing() const{
+    return _increment;
+  }
+  
+  /* increments.*/
+  virtual void increment() ;
+  virtual void decrement() ;
+};
+
+//
+// Chaining iterators definitions
+//
+///////////////////////////////////////////////////////////
+
+/*! A ViewEdge Iterator used to follow ViewEdges the most naturally.
+ *  For example, it will follow visible ViewEdges of same nature.
+ *  As soon, as the nature or the visibility changes, the iteration
+ *  stops (by setting the pointed ViewEdge to 0).
+ *  In the case of an iteration over a set of ViewEdge that are both
+ *  Silhouette and Crease, there will be a precedence of the silhouette
+ *  over the crease criterion.
+ */
+class LIB_STROKE_EXPORT ChainSilhouetteIterator : public ChainingIterator
+{
+public:
+  /*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration
+   *  and its orientation.
+   *  \param iRestrictToSelection
+   *    Indicates whether to force the chaining to stay within
+   *    the set of selected ViewEdges or not.
+   *  \param begin
+   *    The ViewEdge from where to start the iteration.
+   *  \param orientation
+   *    If true, we'll look for the next ViewEdge among the
+   *    ViewEdges that surround the ending ViewVertex of begin.
+   *    If false, we'll search over the ViewEdges surrounding
+   *    the ending ViewVertex of begin.
+   */
+  ChainSilhouetteIterator(bool iRestrictToSelection = true, ViewEdge* begin = NULL, bool orientation = true)
+    : ChainingIterator(iRestrictToSelection, true, begin, orientation) {}
+
+  /*! Copy constructor */
+  ChainSilhouetteIterator(const ChainSilhouetteIterator& brother)
+    : ChainingIterator(brother) {}
+
+  /*! Returns the string "ChainSilhouetteIterator" */
+  virtual string getExactTypeName() const {
+    return "ChainSilhouetteIterator";
+  }
+
+  /*! This method iterates over the potential next 
+   *  ViewEdges and returns the one that will be 
+   *  followed next.
+   *  When reaching the end of a chain, 0 is returned.
+   */
+  virtual ViewEdge * traverse(const AdjacencyIterator& it);
+
+};
+
+//
+// ChainPredicateIterator
+//
+///////////////////////////////////////////////////////////
+
+/*! A "generic" user-controlled ViewEdge iterator. This iterator
+ *  is in particular built from a unary predicate and a binary predicate.
+ *  First, the unary predicate is evaluated for all potential next ViewEdges
+ *  in order to only keep the ones respecting a certain constraint.
+ *  Then, the binary predicate is evaluated on the current ViewEdge
+ *  together with each ViewEdge of the previous selection. The first
+ *  ViewEdge respecting both the unary predicate and the binary predicate
+ *  is kept as the next one. If none of the potential next ViewEdge respects
+ *  these 2 predicates, 0 is returned.
+ */
+class LIB_STROKE_EXPORT ChainPredicateIterator : public ChainingIterator
+{
+protected:
+  BinaryPredicate1D *_binary_predicate; // the caller is responsible for the deletion of this object
+  UnaryPredicate1D  *_unary_predicate;  // the caller is responsible for the deletion of this object
+public:
+
+  /*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation.
+   *  \param iRestrictToSelection
+   *    Indicates whether to force the chaining to stay within
+   *    the set of selected ViewEdges or not.
+   *  \param iRestrictToUnvisited
+   *    Indicates whether a ViewEdge that has already been chained
+   *    must be ignored ot not.
+   *  \param begin
+   *    The ViewEdge from where to start the iteration.
+   *  \param orientation
+   *    If true, we'll look for the next ViewEdge among the
+   *    ViewEdges that surround the ending ViewVertex of begin.
+   *    If false, we'll search over the ViewEdges surrounding
+   *    the ending ViewVertex of begin.
+   */
+  ChainPredicateIterator(bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge* begin = NULL, bool orientation = true)
+    : ChainingIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation) {
+    _binary_predicate = 0;
+    _unary_predicate = 0;
+  }
+
+  /*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting ViewEdge and its orientation.
+   *  \param iRestrictToSelection
+   *    Indicates whether to force the chaining to stay within
+   *    the set of selected ViewEdges or not.
+   *  \param iRestrictToUnvisited
+   *    Indicates whether a ViewEdge that has already been chained
+   *    must be ignored ot not.
+   *  \param upred
+   *    The unary predicate that the next ViewEdge must satisfy.
+   *  \param bpred
+   *    The binary predicate that the next ViewEdge must satisfy
+   *    together with the actual pointed ViewEdge. 
+   *  \param begin
+   *    The ViewEdge from where to start the iteration.
+   *  \param orientation
+   *    If true, we'll look for the next ViewEdge among the
+   *    ViewEdges that surround the ending ViewVertex of begin.
+   *    If false, we'll search over the ViewEdges surrounding
+   *    the ending ViewVertex of begin.
+   */
+  ChainPredicateIterator(UnaryPredicate1D& upred, BinaryPredicate1D& bpred, bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge* begin = NULL, bool orientation = true)
+    : ChainingIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation) {
+    _unary_predicate = &upred;
+    _binary_predicate = &bpred;
+  }
+
+  /*! Copy constructor */
+  ChainPredicateIterator(const ChainPredicateIterator& brother)
+    : ChainingIterator(brother){
+    _unary_predicate = brother._unary_predicate;
+    _binary_predicate = brother._binary_predicate;
+  }
+
+  /*! Destructor. */
+  virtual ~ChainPredicateIterator(){
+    _unary_predicate = 0;
+    _binary_predicate = 0;
+  }
+
+  /*! Returns the string "ChainPredicateIterator" */
+  virtual string getExactTypeName() const {
+    return "ChainPredicateIterator";
+  }
+
+  /*! This method iterates over the potential next 
+   *  ViewEdges and returns the one that will be 
+   *  followed next.
+   *  When reaching the end of a chain, 0 is returned.
+   */
+  virtual ViewEdge * traverse(const AdjacencyIterator &it); 
+};
+
+#endif // CHAININGITERATORS_H
diff --git a/source/blender/freestyle/intern/stroke/ContextFunctions.cpp b/source/blender/freestyle/intern/stroke/ContextFunctions.cpp
new file mode 100755
index 00000000000..b55da1fb0f8
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/ContextFunctions.cpp
@@ -0,0 +1,60 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ContextFunctions.h"
+#include "../view_map/SteerableViewMap.h"
+#include "../system/TimeStamp.h"
+namespace ContextFunctions {
+  
+  unsigned GetTimeStampCF(){
+    return TimeStamp::instance()->getTimeStamp();
+  }
+
+  unsigned GetCanvasWidthCF(){
+    return Canvas::getInstance()->width();
+  }
+
+  unsigned GetCanvasHeightCF(){
+    return Canvas::getInstance()->height();
+  }
+  void LoadMapCF(const char *iFileName, const char *iMapName, unsigned iNbLevels, float iSigma ){
+    return Canvas::getInstance()->loadMap(iFileName, iMapName, iNbLevels,iSigma);
+  }
+
+  float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y){
+    Canvas * canvas = Canvas::getInstance();
+    return canvas->readMapPixel(iMapName, level, x,y);
+  }
+
+  float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y){
+	  SteerableViewMap *svm = Canvas::getInstance()->getSteerableViewMap();
+    return svm->readCompleteViewMapPixel(level,x,y);
+  }
+
+  float ReadDirectionalViewMapPixelCF(int iOrientation, int level, unsigned x, unsigned y){
+    SteerableViewMap *svm = Canvas::getInstance()->getSteerableViewMap();
+    return svm->readSteerableViewMapPixel(iOrientation, level,x,y);
+  }
+
+  FEdge * GetSelectedFEdgeCF(){
+    return Canvas::getInstance()->selectedFEdge();
+  }
+}
diff --git a/source/blender/freestyle/intern/stroke/ContextFunctions.h b/source/blender/freestyle/intern/stroke/ContextFunctions.h
new file mode 100755
index 00000000000..37c98656fa7
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/ContextFunctions.h
@@ -0,0 +1,124 @@
+//
+//  Filename         : AdvancedFunctions0D.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Functions related to context queries
+//  Date of creation : 20/12/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CONTEXT_FUNCTIONS_HPP
+# define CONTEXT_FUNCTIONS_HPP
+
+# include "Canvas.h"
+# include "../image/Image.h"
+# include "../image/GaussianFilter.h"
+
+/*! \file ContextFunctions.h
+ *  Interface to access the context related
+ *  information.
+ */
+//
+// Context Functions definitions
+//
+///////////////////////////////////////////////////////////
+/*! namespace containing all the Context related functions */
+namespace ContextFunctions {
+
+  // GetTimeStamp
+  LIB_STROKE_EXPORT
+  /*! Returns the system time stamp */
+  unsigned GetTimeStampCF();
+
+  // GetCanvasWidth
+  /*! Returns the canvas width */
+  LIB_STROKE_EXPORT
+  unsigned GetCanvasWidthCF();
+ 
+  // GetCanvasHeight
+  /*! Returns the canvas width */
+  LIB_STROKE_EXPORT 
+  unsigned GetCanvasHeightCF();
+  
+  // Load map
+  /*! Loads an image map for further reading */
+  LIB_STROKE_EXPORT 
+  void LoadMapCF(const char *iFileName, const char *iMapName, unsigned iNbLevels=4, float iSigma=1.f);
+
+  // ReadMapPixel
+  /*! Reads a pixel in a user-defined map 
+   *  \return the floating value stored for that pixel
+   *  \param iMapName
+   *    The name of the map
+   *  \param level
+   *    The level of the pyramid in which we wish to read the pixel
+   *  \param x
+   *    The x-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   *  \param y
+   *    The y-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   */
+  LIB_STROKE_EXPORT 
+  float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y);
+
+  // ReadCompleteViewMapPixel
+  /*! Reads a pixel in the complete view map
+   *  \return the floating value stored for that pixel
+   *  \param level
+   *    The level of the pyramid in which we wish to read the pixel
+   *  \param x
+   *    The x-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   *  \param y
+   *    The y-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   */
+  LIB_STROKE_EXPORT 
+  float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y);
+
+  // ReadOrientedViewMapPixel
+  /*! Reads a pixel in one of the oriented view map images
+   *  \return the floating value stored for that pixel
+   *  \param iOrientation
+   *    The number telling which orientation we want to check
+   *  \param level
+   *    The level of the pyramid in which we wish to read the pixel
+   *  \param x
+   *    The x-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   *  \param y
+   *    The y-coordinate of the pixel we wish to read. The origin is
+   *    in the lower-left corner.
+   */
+  LIB_STROKE_EXPORT 
+  float ReadDirectionalViewMapPixelCF(int iOrientation, int level, unsigned x, unsigned y);
+
+  // DEBUG
+  LIB_STROKE_EXPORT 
+  FEdge * GetSelectedFEdgeCF();
+
+} // end of namespace ContextFunctions
+
+#endif // CONTEXT_FUNCTIONS_HPP
+
diff --git a/source/blender/freestyle/intern/stroke/Curve.cpp b/source/blender/freestyle/intern/stroke/Curve.cpp
new file mode 100755
index 00000000000..f7b255c3ef4
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Curve.cpp
@@ -0,0 +1,818 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Curve.h"
+#include "CurveIterators.h"
+#include "CurveAdvancedIterators.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             CurvePoint         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+CurvePoint::CurvePoint()
+{
+  __A=0;
+  __B=0;
+  _t2d=0;
+}
+
+CurvePoint::CurvePoint(SVertex *iA, SVertex *iB, float t) 
+{
+  __A=iA;
+  __B=iB;
+  _t2d=t;
+  if((iA == 0) && (t == 1.f))
+  {
+    _Point2d=__B->point2d();
+    _Point3d=__B->point3d();
+  }
+  else if((iB == 0) && (t == 0.f))
+  {
+    _Point2d=__A->point2d();
+    _Point3d=__A->point3d();
+  }
+  else
+  {
+    _Point2d=__A->point2d()+_t2d*(__B->point2d()-__A->point2d());
+    _Point3d=__A->point3d()+_t2d*(__B->point3d()-__A->point3d());
+  }
+}
+
+CurvePoint::CurvePoint(CurvePoint *iA, CurvePoint *iB, float t3) 
+{
+  float t1=iA->t2d();
+  float t2=iB->t2d();
+  if((iA->A() == iB->A()) && (iA->B() == iB->B()) && (iA->A() != 0) && (iA->B() != 0) && (iB->A() != 0) && (iB->B() != 0))
+  {
+    __A=iA->A();
+    __B=iB->B();
+    _t2d=t1+t2*t3-t1*t3;
+  }
+  else if((iA->B() == 0) && (iB->B() == 0))
+  {
+    __A = iA->A();
+    __B = iB->A();
+    _t2d = t3;
+  }
+  else if((iA->t2d() == 0) && (iB->t2d() == 0))
+  {
+    __A = iA->A();
+    __B = iB->A();
+    _t2d = t3;
+  }
+  else if(iA->A() == iB->A()){
+    if(iA->t2d() == 0){
+      __A = iB->A();
+      __B = iB->B();
+      _t2d = t3;
+    }else if(iB->t2d() == 0){
+      __A = iA->A();
+      __B = iA->B();
+      _t2d = t3;
+    }
+  }else if(iA->B() == iB->B()){
+    if(iA->t2d() == 1){
+      __A = iB->A();
+      __B = iB->B();
+      _t2d = t3;
+    }else if(iB->t2d() == 1){
+      __A = iA->A();
+      __B = iA->B();
+      _t2d = t3;
+    }
+  }
+  else if(iA->B() == iB->A())
+  {
+    if((iA->t2d() != 1.f) && (iB->t2d() == 0.f))
+    {
+      __A = iA->A();
+      __B = iA->B();
+      _t2d=t1+t3-t1*t3;
+      //_t2d = t3;
+    }
+    else if((iA->t2d() == 1.f) && (iB->t2d() != 0.f))
+    {
+      __A = iB->A();
+      __B = iB->B();
+      //_t2d = t3;
+      _t2d=t2*t3;
+    }
+    
+  }
+  //_Point2d=__A->point2d()+_t2d*(__B->point2d()-__A->point2d());
+  //_Point3d=__A->point3d()+_t2d*(__B->point3d()-__A->point3d());
+
+  _Point2d= iA->point2d()+t3*(iB->point2d()-iA->point2d());
+  _Point3d=__A->point3d()+_t2d*(__B->point3d()-__A->point3d());
+}
+
+CurvePoint::CurvePoint(const CurvePoint& iBrother) 
+{
+  __A=iBrother.__A;
+  __B=iBrother.__B;
+  _t2d=iBrother._t2d;
+  _Point2d=iBrother._Point2d;
+  _Point3d=iBrother._Point3d;
+}
+
+CurvePoint& CurvePoint::operator=(const CurvePoint& iBrother)
+{
+  __A=iBrother.__A;
+  __B=iBrother.__B;
+  _t2d=iBrother._t2d;
+  _Point2d=iBrother._Point2d;
+  _Point3d=iBrother._Point3d;
+  return *this;
+}
+
+
+FEdge *CurvePoint::fedge() 
+{
+  if(getNature() & Nature::T_VERTEX)
+    return 0;
+  return __A->fedge();
+}
+
+
+FEdge* CurvePoint::getFEdge(Interface0D& inter)
+{
+  CurvePoint* iVertexB = dynamic_cast<CurvePoint*>(&inter);
+  if (!iVertexB)
+    return 0;
+  if(((__A == iVertexB->__A) && (__B == iVertexB->__B))
+    ||
+    ((__A == iVertexB->__B) && (__B == iVertexB->__A)))
+    return __A->getFEdge(*__B);
+  else if(__B == 0)
+  {
+    if(iVertexB->__B == 0)
+      return __A->getFEdge(*(iVertexB->__A));
+    else if(iVertexB->__A == __A)
+      return __A->getFEdge(*(iVertexB->__B));
+    else if(iVertexB->__B == __A)
+      return __A->getFEdge(*(iVertexB->__A));
+  }
+  else if(iVertexB->__B == 0)
+  {
+    if(iVertexB->__A == __A)
+      return __B->getFEdge(*(iVertexB->__A));
+    else if(iVertexB->__A == __B)
+      return __A->getFEdge(*(iVertexB->__A));
+  }
+  else if(__B == iVertexB->__A)
+  {
+    if((_t2d != 1) && (iVertexB->_t2d == 0))
+      return __A->getFEdge(*__B);
+    if((_t2d == 1) && (iVertexB->_t2d != 0))
+      return iVertexB->__A->getFEdge(*(iVertexB->__B));
+  }
+  else if(__B == iVertexB->__B)
+  {
+    if((_t2d != 1) && (iVertexB->_t2d == 1))
+      return __A->getFEdge(*__B);
+    if((_t2d == 1) && (iVertexB->_t2d != 1))
+      return iVertexB->__A->getFEdge(*(iVertexB->__B));
+  }
+  else if(__A == iVertexB->__A)
+  {
+    if((_t2d == 0) && (iVertexB->_t2d != 0))
+      return iVertexB->__A->getFEdge(*(iVertexB->__B));
+    if((_t2d != 0) && (iVertexB->_t2d == 0))
+      return __A->getFEdge(*__B);
+  }
+  else if(__A == iVertexB->__B)
+  {
+    if((_t2d == 0) && (iVertexB->_t2d != 1))
+      return iVertexB->__A->getFEdge(*(iVertexB->__B));
+    if((_t2d != 0) && (iVertexB->_t2d == 1))
+      return __A->getFEdge(*__B);
+  }
+  
+  cerr << "Warning: you should not be there..." << endl;
+
+  return 0;
+}
+
+
+ Vec3r CurvePoint::normal() const
+{
+  if(__B == 0)
+    return __A->normal();
+  if(__A == 0)
+    return __B->normal();
+  Vec3r Na = __A->normal();
+  if(Exception::getException())
+    Na = Vec3r(0,0,0);
+  Vec3r Nb = __B->normal();
+  if(Exception::getException())
+    Nb = Vec3r(0,0,0);
+  // compute t3d:
+  real t3d = SilhouetteGeomEngine::ImageToWorldParameter(__A->getFEdge(*__B),_t2d);
+  return ((1-t3d)*Na+t3d*Nb);
+}
+
+
+ // Material CurvePoint::material() const 
+ //{
+ //  if(__A == 0)
+ //    return __B->material();
+ //  return __A->material();
+ //}
+
+
+//  Id CurvePoint::shape_id() const 
+// {
+//   if(__A == 0)
+//     return __B->shape_id();
+//   return __A->shape_id();
+// }
+
+
+ const SShape * CurvePoint::shape() const 
+{
+  if(__A == 0)
+    return __B->shape();
+  return __A->shape();
+}
+
+
+ 
+//  float CurvePoint::shape_importance() const 
+// {
+
+//   if(__A == 0)
+
+//     return __B->shape_importance();
+//   return __A->shape_importance();
+// } 
+
+  
+ // const unsigned CurvePoint::qi() const 
+ //{
+ //  if(__A == 0)
+ //    return __B->qi();
+ //  if(__B == 0)
+ //    return __A->qi();
+ //  return __A->getFEdge(*__B)->qi();
+ //}
+
+  
+ occluder_container::const_iterator CurvePoint::occluders_begin() const 
+{
+  if(__A == 0)
+    return __B->occluders_begin();
+  if(__B == 0)
+    return __A->occluders_begin();
+  return __A->getFEdge(*__B)->occluders_begin();
+}
+  
+ occluder_container::const_iterator CurvePoint::occluders_end() const 
+{
+  if(__A == 0)
+    return __B->occluders_end();
+  if(__B == 0)
+    return __A->occluders_end();
+  return __A->getFEdge(*__B)->occluders_end();
+}
+  
+ bool CurvePoint::occluders_empty() const 
+{
+  if(__A == 0)
+    return __B->occluders_empty();
+  if(__B == 0)
+    return __A->occluders_empty();
+  return __A->getFEdge(*__B)->occluders_empty();
+}
+  
+ int CurvePoint::occluders_size() const 
+{
+  if(__A == 0)
+    return __B->occluders_size();
+  if(__B == 0)
+    return __A->occluders_size();
+  return __A->getFEdge(*__B)->occluders_size();
+}
+  
+ const SShape * CurvePoint::occluded_shape() const 
+{
+  if(__A == 0)
+    return __B->occluded_shape();
+  if(__B == 0)
+    return __A->occluded_shape();
+  return __A->getFEdge(*__B)->occluded_shape();
+}
+  
+ const Polygon3r& CurvePoint::occludee() const 
+{
+  if(__A == 0)
+    return __B->occludee();
+  if(__B == 0)
+    return __A->occludee();
+  return __A->getFEdge(*__B)->occludee();
+}
+  
+ const bool  CurvePoint::occludee_empty() const 
+{
+  if(__A == 0)
+    return __B->occludee_empty();
+  if(__B == 0)
+    return __A->occludee_empty();
+  return __A->getFEdge(*__B)->occludee_empty();
+}
+  
+ real CurvePoint::z_discontinuity() const 
+{
+  if(__A == 0)
+    return __B->z_discontinuity();
+  if(__B == 0)
+    return __A->z_discontinuity();
+  if(__A->getFEdge(*__B) == 0)
+    return 0.0;
+
+  return __A->getFEdge(*__B)->z_discontinuity();
+}
+//  
+// float CurvePoint::local_average_depth() const 
+//{
+//  return local_average_depth_function<CurvePoint >(this);
+//}
+//  
+// float CurvePoint::local_depth_variance() const 
+//{
+//  return local_depth_variance_function<CurvePoint >(this);
+//}
+//  
+// real CurvePoint::local_average_density(float sigma) const
+//{
+//  //return local_average_density<CurvePoint >(this);
+//
+//  return density_function<CurvePoint >(this);
+//}
+// Vec3r shaded_color() const ;
+//   
+//  Vec3r CurvePoint::orientation2d() const 
+// {
+//   if(__A == 0)
+//     return __B->orientation2d();
+//   if(__B == 0)
+//     return __A->orientation2d();
+//   return __B->point2d()-__A->point2d();
+// }
+//   
+//  Vec3r CurvePoint::orientation3d() const 
+// {
+//   if(__A == 0)
+//     return __B->orientation3d();
+//   if(__B == 0)
+//     return __A->orientation3d();
+//   return __B->point3d()-__A->point3d();
+// }
+
+// real curvature2d() const {return viewedge()->curvature2d((_VertexA->point2d()+_VertexB->point2d())/2.0);}
+//  
+// Vec3r CurvePoint::curvature2d_as_vector() const 
+//{
+//  //  Vec3r edgeA = (_FEdges[0])->orientation2d().normalize();
+//  //  Vec3r edgeB = (_FEdges[1])->orientation2d().normalize();
+//  //  return edgeA+edgeB;
+//  //  
+//  if(__A == 0)
+//    return __B->curvature2d_as_vector();
+//  if(__B == 0)
+//    return __A->curvature2d_as_vector();
+//  return ((1-_t2d)*__A->curvature2d_as_vector()+_t2d*__B->curvature2d_as_vector());
+//}
+//  
+// real CurvePoint::curvature2d_as_angle() const 
+//{
+//  //  Vec3r edgeA = (_FEdges[0])->orientation2d();
+//  //  Vec3r edgeB = (_FEdges[1])->orientation2d();
+//  //  Vec2d N1(-edgeA.y(), edgeA.x());N1.normalize();
+//  //  Vec2d N2(-edgeB.y(), edgeB.x());N2.normalize();
+//  //  return acos((N1*N2));
+//
+//  if(__A == 0)
+//    return __B->curvature2d_as_angle();
+//  if(__B == 0)
+//    return __A->curvature2d_as_angle();
+//  return ((1-_t2d)*__A->curvature2d_as_angle()+_t2d*__B->curvature2d_as_angle());
+//}
+
+  
+real CurvePoint::curvatureFredo() const 
+{
+  if(__A == 0)
+    return __B->curvatureFredo();
+  if(__B == 0)
+    return __A->curvatureFredo();
+  return ((1-_t2d)*__A->curvatureFredo()+_t2d*__B->curvatureFredo());
+}
+  
+Vec2d CurvePoint::directionFredo () const 
+{
+  if(__A == 0)
+    return __B->directionFredo();
+  if(__B == 0)
+    return __A->directionFredo();
+  return ((1-_t2d)*__A->directionFredo()+_t2d*__B->directionFredo());
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             Curve              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/* for  functions */
+
+
+Curve::~Curve()
+{
+  if(!_Vertices.empty())
+  {
+    for(vertex_container::iterator it=_Vertices.begin(), itend =_Vertices.end();
+    it!=itend;
+    ++it)
+    {
+      delete (*it);
+    }
+    _Vertices.clear();
+  }
+}
+
+/*! iterators access */
+Curve::point_iterator Curve::points_begin(float step) 
+{
+  vertex_container::iterator second = _Vertices.begin();++second;
+  return point_iterator(_Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), _nSegments, step, 0.f, 0.f);
+  //return point_iterator(_Vertices.begin(), second, _nSegments, step, 0.f, 0.f);
+}
+Curve::const_point_iterator Curve::points_begin(float step) const 
+{
+  vertex_container::const_iterator second = _Vertices.begin();++second;
+  return const_point_iterator(_Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), _nSegments, step, 0.f, 0.f);
+  //return const_point_iterator(_Vertices.begin(), second, _nSegments, step, 0.f, 0.f);
+}
+Curve::point_iterator Curve::points_end(float step)  
+{
+  return point_iterator(_Vertices.end(), _Vertices.end(), _Vertices.begin(), _Vertices.end(), _nSegments, step, 1.f, _Length);
+  //return point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.f, _Length);
+}
+Curve::const_point_iterator Curve::points_end(float step) const   
+{
+  return const_point_iterator(_Vertices.end(), _Vertices.end(), _Vertices.begin(), _Vertices.end(), _nSegments, step, 1.f, _Length);
+  //return const_point_iterator(_Vertices.end(), _Vertices.end(), _nSegments, step, 1.f, _Length);
+}
+
+// Adavnced Iterators access
+Curve::point_iterator Curve::vertices_begin(){return points_begin(0);}
+Curve::const_point_iterator Curve::vertices_begin() const {return points_begin(0);}
+Curve::point_iterator Curve::vertices_end(){return points_end(0);}
+Curve::const_point_iterator Curve::vertices_end() const {return points_end(0);}
+
+// specialized iterators access
+CurveInternal::CurvePointIterator Curve::curvePointsBegin(float t){
+  vertex_container::iterator second = _Vertices.begin();++second;
+  return CurveInternal::CurvePointIterator(_Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), 0, _nSegments, _Length, t, 0.f, 0.f);
+}
+
+CurveInternal::CurvePointIterator Curve::curvePointsEnd(float t){
+  vertex_container::iterator last = _Vertices.end();--last;
+  return CurveInternal::CurvePointIterator(last, _Vertices.end(), _Vertices.begin(), _Vertices.end(), _nSegments, _nSegments, _Length, t, 0.f, _Length);
+}
+
+CurveInternal::CurvePointIterator  Curve::curveVerticesBegin(){
+  return curvePointsBegin(0);
+}
+
+CurveInternal::CurvePointIterator Curve::curveVerticesEnd(){
+  return curvePointsEnd(0);
+}
+
+Interface0DIterator Curve::pointsBegin(float t){
+  vertex_container::iterator second = _Vertices.begin();++second;
+  Interface0DIterator ret(new CurveInternal::CurvePointIterator(_Vertices.begin(), second, _Vertices.begin(), _Vertices.end(), 0, _nSegments, _Length, t, 0.f, 0.f));
+  return ret;
+}
+
+Interface0DIterator Curve::pointsEnd(float t){
+  vertex_container::iterator last = _Vertices.end();--last;
+  Interface0DIterator ret(new CurveInternal::CurvePointIterator(last, _Vertices.end(), _Vertices.begin(), _Vertices.end(), _nSegments, _nSegments, _Length, t, 0.f, _Length));
+  return ret;
+}
+
+Interface0DIterator Curve::verticesBegin(){
+  return pointsBegin(0);
+}
+
+Interface0DIterator Curve::verticesEnd(){
+  return pointsEnd(0);
+}
+
+
+// Vec3r shaded_color(int iCombination = 0) const ;
+//
+// Vec3r  Curve::orientation2d(point_iterator it) const 
+//{
+//  return (*it)->orientation2d();
+//}
+/* template <class BaseVertex> */
+/*  Vec3r  Curve::orientation2d(int iCombination) const  */
+/* { */
+/*   return edge_orientation2d_function<Curve >(this, iCombination); */
+/* } */
+//
+// Vec3r  Curve::orientation3d(point_iterator it) const 
+//{
+//  return (*it)->orientation3d();
+//}
+/*  */
+/*  Vec3r  Curve::orientation3d(int iCombination) const  */
+/* { */
+/*   return edge_orientation3d_function<Curve >(this, iCombination); */
+/* } */
+// real curvature2d(point_iterator it) const {return (*it)->curvature2d();}
+// real curvature2d(int iCombination = 0) const ;
+
+// Material Curve::material() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  const Material& mat = (*v)->material();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->material() != mat)
+//      Exception::raiseException();
+//  }
+//  return mat;
+//}
+
+// int Curve::qi() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  int qi_= (*v)->qi();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->qi() != qi_)
+//      Exception::raiseException();
+//  }
+//  return qi_;
+//}
+// occluder_container::const_iterator occluders_begin() const {return _FEdgeA->occluders().begin();}
+// occluder_container::const_iterator occluders_end() const {return _FEdgeA->occluders().end();}
+
+//int Curve::occluders_size() const 
+//{
+//  return qi();
+//}
+
+// bool Curve::occluders_empty() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  bool empty = (*v)->occluders_empty();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occluders_empty() != empty)
+//      Exception::raiseException();
+//  }
+//  return empty;
+//}
+// const Polygon3r& occludee() const {return *(_FEdgeA->aFace());}
+
+// const SShape * Curve::occluded_shape() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  const SShape *sshape = (*v)->occluded_shape();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occluded_shape() != sshape)
+//      Exception::raiseException();
+//  }
+//  return sshape;
+//}
+
+
+// const bool Curve::occludee_empty() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  bool empty = (*v)->occludee_empty();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occludee_empty() != empty)
+//      Exception::raiseException();
+//  }
+//  return empty;
+//}
+/*  */
+/*  real Curve::z_discontinuity(int iCombination) const  */
+/* { */
+/*   return z_discontinuity_edge_function<Curve >(this, iCombination); */
+/* } */
+
+//  int Curve::shape_id() const 
+// {
+//   const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//   Id id = (*v)->shape_id();
+//   for(;v!=vend;++v)
+//   {
+//     if((*v)->shape_id() != id)
+//       Exception::raiseException();
+//   }
+//   return id.first;
+// }
+
+
+// const SShape * Curve::shape() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  const SShape *sshape = (*v)->shape();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->shape() != sshape)
+//      Exception::raiseException();
+//  }
+//  return sshape;
+//}
+
+
+// occluder_container::const_iterator Curve::occluders_begin() const 
+//{
+//  const_vertex_iterator v=vertices_begin();
+//  return (*v)->occluders_begin();
+//}
+//
+//
+// occluder_container::const_iterator Curve::occluders_end() const 
+//{
+//  const_vertex_iterator v=vertices_end();
+//  return (*v)->occluders_end();
+//}
+
+/*  */
+/*  Vec3r Curve::curvature2d_as_vector(int iCombination) const  */
+/* { */
+/*   return curvature2d_as_vector_edge_function<Curve >(this, iCombination); */
+/* } */
+/*  */
+/*  real Curve::curvature2d_as_angle(int iCombination) const  */
+/* { */
+/*   return curvature2d_as_angle_edge_function<Curve >(this, iCombination); */
+/* } */
+
+/*  */
+/*  float Curve::shape_importance(int iCombination) const  */
+/* { */
+/*   return shape_importance_edge_function<Curve >(this, iCombination); */
+/* }  */
+
+/*  */
+/*  float Curve::local_average_depth(int iCombination) const */
+/* { */
+/*   return local_average_depth_edge_function<Curve >(this, iCombination); */
+/* } */
+/*  */
+/*  float Curve::local_depth_variance(int iCombination ) const  */
+/* { */
+/*   return local_depth_variance_edge_function<Curve >(this, iCombination); */
+/*   //  local_depth_variance_functor<Point> functor; */
+/*   //  float result; */
+/*   //  Evaluate<float, local_depth_variance_functor<Point> >(&functor, iCombination, result);  */
+/*   //  return result; */
+/* } */
+
+/*  */
+/*  real Curve::local_average_density(float sigma, int iCombination ) const */
+/* { */
+/*   return density_edge_function<Curve >(this, iCombination); */
+/*   //  density_functor<Point> functor; */
+/*   //  real result; */
+/*   //  Evaluate<real, density_functor<Point> >(&functor, iCombination, result);  */
+/*   //  return result; */
+/* } */
+
+#define EPS_CURVA_DIR 0.01
+
+
+void Curve::computeCurvatureAndOrientation ()
+{
+// 	const_vertex_iterator v=vertices_begin(), vend=vertices_end(), v2, prevV, v0;
+// 	Vec2d p0, p1, p2;
+// 	Vec3r p;
+
+// 	p=(*v)->point2d();
+// 	p0=Vec2d(p[0], p[1]);
+// 	prevV=v; ++v;
+// 	p=(*v)->point2d();
+// 	p1=Vec2d(p[0], p[1]);
+// 	Vec2d prevDir(p1-p0);
+
+// 	for(;v!=vend;++v)
+// 	{
+// 		v2=v; ++v2;
+// 		if (v2==vend) break;
+// 		Vec3r p2=(*v2)->point2d();
+		
+// 		Vec2d BA=p0-p1;
+// 		Vec2d BC=p2-p1;
+// 		real lba=BA.norm(), lbc=BC.norm();
+// 		BA.normalizeSafe();
+// 		BC.normalizeSafe();
+// 		Vec2d normalCurvature=BA+BC;
+// 		Vec2d dir=Vec2d(BC-BA);
+// 		Vec2d normal=Vec2d(-dir[1], dir[0]);
+
+// 		normal.normalizeSafe();
+// 		real curvature=normalCurvature*normal;
+// 		if (lba+lbc > MY_EPSILON)
+// 		  curvature/=(0.5*lba+lbc);
+// 		if (dir.norm() < MY_EPSILON)
+// 		  dir=0.1*prevDir;
+// 		(*v)->setCurvatureFredo(curvature);
+// 		(*v)->setDirectionFredo(dir);
+
+// 		prevV=v; p0=p1; p1=p2; prevDir=dir; prevDir.normalize();
+// 	}
+// 	(*v)->setCurvatureFredo((*prevV)->curvatureFredo());
+// 	(*v)->setDirectionFredo((*v)->point2d()-(*prevV)->point2d());
+// 	v0=vertices_begin(); v2=v0; ++v2;
+// 	(*v0)->setCurvatureFredo((*v2)->curvatureFredo());
+// 	(*v0)->setDirectionFredo((*v2)->point2d()-(*v0)->point2d());
+
+// 	//closed curve case one day...
+
+// 	//
+// 	return;
+
+// 	//numerical degeneracy verification.. we'll see later 
+// 	const_vertex_iterator vLastReliable=vertices_begin();
+
+// 	v=vertices_begin();
+// 	p=(*v)->point2d();
+// 	p0=Vec2d(p[0], p[1]);
+// 	prevV=v; ++v;
+// 	p=(*v)->point2d();
+// 	p1=Vec2d(p[0], p[1]);
+// 	bool isReliable=false;
+// 	if ((p1-p0).norm>EPS_CURVA) 
+// 	{
+// 		vLastReliable=v;
+// 		isReliable=true;
+// 	}
+
+// 	for(;v!=vend;++v)
+// 	{
+// 		v2=v; ++v2;
+// 		if (v2==vend) break;
+// 		Vec3r p2=(*v2)->point2d();
+		
+// 		Vec2d BA=p0-p1;
+// 		Vec2d BC=p2-p1;
+// 		real lba=BA.norm(), lbc=BC.norm();
+
+// 		if ((lba+lbc)<EPS_CURVA)
+// 		{
+// 			isReliable=false;
+// 			cerr<<"/";
+// 		}
+// 		else
+// 		{
+// 			if (!isReliable)//previous points were not reliable
+// 			{
+// 				const_vertex_iterator vfix=vLastReliable;
+// 				vfix++;
+// 				for (; vfix!=v; ++vfix)
+// 				{
+// 					(*vfix)->setCurvatureFredo((*v)->curvatureFredo());
+// 					(*vfix)->setDirectionFredo((*v)->directionFredo());
+// 				}
+// 			}
+// 			isReliable=true; 
+// 			vLastReliable=v;
+// 		}	
+// 		prevV=v; p0=p1; p1=p2;
+// 	}
+
+}
diff --git a/source/blender/freestyle/intern/stroke/Curve.h b/source/blender/freestyle/intern/stroke/Curve.h
new file mode 100755
index 00000000000..7fbe7e701e9
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Curve.h
@@ -0,0 +1,463 @@
+//
+//  Filename         : Curve.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define a container for curves
+//  Date of creation : 11/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CURVE_H
+# define CURVE_H
+
+# include <deque>
+# include "../system/BaseIterator.h"
+# include "../geometry/Geom.h"
+//# include "../scene_graph/Material.h"
+# include "../view_map/Silhouette.h"
+# include "../view_map/SilhouetteGeomEngine.h"
+# include "../view_map/Interface0D.h"
+# include "../view_map/Interface1D.h"
+
+using namespace std;
+using namespace Geometry;
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             CurvePoint         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/*! Class to represent a point of a curve.
+ *  A CurvePoint can be any point of a 1D curve
+ *  (it doesn't have to be a vertex of the curve).
+ *  Any Interface1D is built upon ViewEdges, themselves
+ *  built upon FEdges. Therefore, a curve is basically
+ *  a polyline made of a list SVertex.
+ *  Thus, a CurvePoint is built by lineraly interpolating
+ *  two SVertex.
+ *  CurvePoint can be used as virtual points while 
+ *  querying 0D information along a curve at a given resolution.
+ */
+class LIB_STROKE_EXPORT CurvePoint : public Interface0D
+{
+public: // Implementation of Interface0D
+  /*! Returns the string "CurvePoint"*/
+  virtual string getExactTypeName() const {
+    return "CurvePoint";
+  }
+
+  // Data access methods
+  /*! Returns the 3D X coordinate of the point */
+  virtual real getX() const {
+    return _Point3d.x();
+  }
+  /*! Returns the 3D Y coordinate of the point */
+  virtual real getY() const {
+    return _Point3d.y();
+  }
+  /*! Returns the 3D Z coordinate of the point */
+  virtual real getZ() const {
+    return _Point3d.z();
+  }
+  /*!  Returns the 3D point. */ 
+  virtual Vec3f getPoint3D() const {
+    return _Point3d;
+  }
+  /*! Returns the projected 3D X coordinate of the point */
+  virtual real getProjectedX() const {
+    return _Point2d.x();
+  }
+  /*! Returns the projected 3D Y coordinate of the point */
+  virtual real getProjectedY() const {
+    return _Point2d.y();
+  }
+  /*! Returns the projected 3D Z coordinate of the point */
+  virtual real getProjectedZ() const {
+    return _Point2d.z();
+  }
+  /*!  Returns the 2D point. */ 
+  virtual Vec2f getPoint2D() const {
+    return Vec2f((float)_Point2d.x(),(float)_Point2d.y());
+  }
+
+  virtual FEdge* getFEdge(Interface0D& inter);
+  /*! Returns the CurvePoint's Id */
+  virtual Id getId() const {
+    Id id;
+    if(_t2d == 0)
+      return __A->getId();
+    else if(_t2d == 1)
+      return __B->getId();
+    return id;
+  }
+  /*! Returns the CurvePoint's Nature */
+  virtual Nature::VertexNature getNature() const {
+    Nature::VertexNature nature = Nature::POINT;
+    if(_t2d == 0)
+      nature |= __A->getNature();
+    else if(_t2d == 1)
+      nature |= __B->getNature();
+    return nature;
+  }
+
+  /*! Cast the Interface0D in SVertex if it can be. */ 
+  virtual SVertex * castToSVertex(){
+    if(_t2d == 0)
+      return __A;
+    else if(_t2d == 1)
+      return __B;
+    return Interface0D::castToSVertex();
+  }
+
+  /*! Cast the Interface0D in ViewVertex if it can be. */ 
+  virtual ViewVertex * castToViewVertex(){
+    if(_t2d == 0)
+      return __A->castToViewVertex();
+    else if(_t2d == 1)
+      return __B->castToViewVertex();
+    return Interface0D::castToViewVertex();
+  }
+
+  /*! Cast the Interface0D in NonTVertex if it can be. */ 
+  virtual NonTVertex * castToNonTVertex(){
+    if(_t2d == 0)
+      return __A->castToNonTVertex();
+    else if(_t2d == 1)
+      return __B->castToNonTVertex();
+    return Interface0D::castToNonTVertex();
+  }
+
+  /*! Cast the Interface0D in TVertex if it can be. */ 
+  virtual TVertex * castToTVertex(){
+    if(_t2d == 0)
+      return __A->castToTVertex();
+    else if(_t2d == 1)
+      return __B->castToTVertex();
+    return Interface0D::castToTVertex();
+  }
+public:
+  typedef SVertex vertex_type;
+protected:
+  SVertex *__A;
+  SVertex *__B;
+  float _t2d;
+  //float _t3d;
+  Vec3r _Point2d;
+  Vec3r _Point3d;
+public:
+  /*! Defult Constructor. */
+   CurvePoint();
+  /*! Builds a CurvePoint from two SVertex and an interpolation
+   *  parameter.
+   *  \param iA
+   *    The first SVertex
+   *  \param iB
+   *    The second SVertex
+   *  \param t2d
+   *    A 2D interpolation parameter
+   *    used to linearly interpolate \a iA and \a iB
+   */
+   CurvePoint(SVertex *iA, SVertex *iB, float t2d) ;
+  /*! Builds a CurvePoint from two CurvePoint and an interpolation parameter.
+   *  \param iA
+   *    The first CurvePoint
+   *  \param iB
+   *    The second CurvePoint
+   *  \param t2d
+   *    The 2D interpolation parameter used
+   *    to linearly interpolate \a iA and \a iB.
+   */
+   CurvePoint(CurvePoint *iA, CurvePoint *iB, float t2d) ;
+  // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d) ;
+  /*! Copy Constructor. */
+   CurvePoint(const CurvePoint& iBrother) ;
+  /*! Operator = */
+   CurvePoint& operator=(const CurvePoint& iBrother) ;
+  /*! Destructor */
+  virtual ~CurvePoint() {}
+  /*! Operator == */
+  bool operator==(const CurvePoint& b){
+    return ((__A==b.__A) && (__B==b.__B) && (_t2d==b._t2d));
+  }
+
+  /* accessors */
+  /*! Returns the first SVertex upon which
+   *  the CurvePoint is built. */
+  inline SVertex * A() {return __A;}
+  /*! Returns the second SVertex upon which
+   *  the CurvePoint is built. */
+  inline SVertex * B() {return __B;}
+  /*! Returns the interpolation parameter. */
+  inline float t2d() const {return _t2d;}
+  //inline const float t3d() const {return _t3d;}
+
+  /* modifiers */
+  /*! Sets the first SVertex upon which to build
+   *  the CurvePoint.
+   */
+  inline void setA(SVertex *iA) {__A = iA;}
+  /*! Sets the second SVertex upon which to build
+   *  the CurvePoint.
+   */
+  inline void setB(SVertex *iB) {__B = iB;}
+  /*! Sets the 2D interpolation parameter to use.
+   */
+  inline void setT2d(float t) {_t2d = t;}
+  //inline void SetT3d(float t) {_t3d = t;}
+
+  /* Information access interface */
+
+  FEdge *fedge() ;
+  inline const Vec3r& point2d() const {return _Point2d;}
+  inline const Vec3r& point3d() const {return _Point3d;}
+   Vec3r normal() const ;
+   //Material material() const ;
+  // Id shape_id() const ;
+   const SShape * shape() const ;
+  // float shape_importance() const ;
+  
+   //const unsigned qi() const ;
+   occluder_container::const_iterator occluders_begin() const ;
+   occluder_container::const_iterator occluders_end() const ;
+   bool occluders_empty() const ;
+   int occluders_size() const ;
+   const Polygon3r& occludee() const ;
+   const SShape * occluded_shape() const ;
+   const bool  occludee_empty() const ;
+   real z_discontinuity() const ;
+  //   float local_average_depth() const ;
+  //   float local_depth_variance() const ;
+  //   real local_average_density(float sigma = 2.3f) const ;
+  // Vec3r shaded_color() const ;
+//    Vec3r orientation2d() const ; 
+//    Vec3r orientation3d() const ;
+  //  // real curvature2d() const {return viewedge()->curvature2d((_VertexA->point2d()+_VertexB->point2d())/2.0);}  
+  //   Vec3r curvature2d_as_vector() const ;
+  //  /*! angle in radians */
+  //   real curvature2d_as_angle() const ;
+
+  real curvatureFredo () const;
+  Vec2d directionFredo () const;
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             Curve              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+namespace CurveInternal {
+  class CurvePoint_const_traits;
+  class CurvePoint_nonconst_traits;
+  template<class Traits> class __point_iterator;
+  class CurvePointIterator;
+} // end of namespace CurveInternal
+
+/*! Base class for curves made of CurvePoints.
+ *  SVertex is the type of the initial curve vertices.
+ *  A Chain is a specialization of a Curve.
+ */
+class LIB_STROKE_EXPORT Curve : public Interface1D
+{
+public:
+  typedef CurvePoint Vertex;
+  typedef CurvePoint Point;
+  typedef Point point_type;
+  typedef Vertex vertex_type;
+  typedef deque<Vertex*> vertex_container;
+
+  /* Iterator to iterate over a vertex edges */
+  
+  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_nonconst_traits > point_iterator;
+  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_const_traits > const_point_iterator;
+  typedef point_iterator vertex_iterator ;
+  typedef const_point_iterator const_vertex_iterator ;
+  
+protected:
+  vertex_container _Vertices;
+  double _Length;
+  Id _Id;
+  unsigned _nSegments; // number of segments
+
+public:
+  /*! Default Constructor. */
+  Curve() {_Length = 0;_Id = 0;_nSegments=0;}
+  /*! Builds a Curve from its id */
+  Curve(const Id& id) {_Length = 0;_Id = id;_nSegments=0;}
+  /*! Copy Constructor. */
+  Curve(const Curve& iBrother) {_Length = iBrother._Length;_Vertices = iBrother._Vertices;_Id=iBrother._Id;_nSegments=0;}
+  /*! Destructor. */
+  virtual ~Curve() ;
+
+  /*
+	fredo's curvature storage
+  */
+  void computeCurvatureAndOrientation ();
+
+  /*! Adds a single vertex (CurvePoint) at the end of the Curve */
+  inline void push_vertex_back(Vertex *iVertex) 
+  {
+    if(!_Vertices.empty())
+    {
+      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
+      _Length += vec_tmp.norm();
+      ++_nSegments;
+    }
+    Vertex * new_vertex = new Vertex(*iVertex);
+    _Vertices.push_back(new_vertex);
+  }
+  /*! Adds a single vertex (SVertex) at the end of the Curve */
+  inline void push_vertex_back(SVertex *iVertex) 
+  {
+    if(!_Vertices.empty())
+    {
+      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
+      _Length += vec_tmp.norm();
+      ++_nSegments;
+    }
+    Vertex *new_vertex = new Vertex(iVertex, 0,0);
+    _Vertices.push_back(new_vertex);
+  }
+  /*! Adds a single vertex (CurvePoint) at the front of the Curve */
+  inline void push_vertex_front(Vertex *iVertex) 
+  {
+    if(!_Vertices.empty())
+    {
+      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
+      _Length += vec_tmp.norm();
+      ++_nSegments;
+    }
+    Vertex * new_vertex = new Vertex(*iVertex);
+    _Vertices.push_front(new_vertex);
+  }
+  /*! Adds a single vertex (SVertex) at the front of the Curve */
+  inline void push_vertex_front(SVertex *iVertex) 
+  {
+    if(!_Vertices.empty())
+    {
+      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
+      _Length += vec_tmp.norm();
+      ++_nSegments;
+    }
+    Vertex *new_vertex = new Vertex(iVertex, 0,0);
+    _Vertices.push_front(new_vertex);
+  }
+  /*! Returns true is the Curve doesn't have any Vertex yet. */
+  inline bool empty() const {return _Vertices.empty();}
+  /*! Returns the 2D length of the Curve.*/
+  inline real getLength2D() const {return _Length;}
+  /*! Returns the Id of the 1D element .*/
+  virtual Id getId() const {
+    return _Id;
+  }
+  /*! Returns the number of segments in the
+   *  oplyline constituing the Curve.
+   */
+  inline unsigned int nSegments() const {return _nSegments;}
+
+  inline void setId(const Id& id){_Id = id;}
+  /* Information access interface */
+  
+  
+  //inline Vec3r shaded_color(int iCombination = 0) const ;
+  //  inline Vec3r  orientation2d(point_iterator it) const ;
+   //Vec3r  orientation2d(int iCombination = 0) const ;
+  //   Vec3r  orientation3d(point_iterator it) const ;
+   //Vec3r  orientation3d(int iCombination = 0) const ;
+  // real curvature2d(point_iterator it) const {return (*it)->curvature2d();}
+  // real curvature2d(int iCombination = 0) const ;
+   //Material material() const ;
+   //int qi() const ;
+   //   occluder_container::const_iterator occluders_begin() const ;
+   //   occluder_container::const_iterator occluders_end() const ;
+   //int occluders_size() const;
+   //bool occluders_empty() const ;
+  // const Polygon3r& occludee() const {return *(_FEdgeA->aFace());}
+   //const SShape * occluded_shape() const;
+   //const bool occludee_empty() const ;
+   //real z_discontinuity(int iCombination = 0) const ;
+  // int shape_id() const ;
+   //const SShape * shape() const ;
+   //float shape_importance(int iCombination=0) const ;
+   //float local_average_depth(int iCombination = 0) const;
+   //float local_depth_variance(int iCombination = 0) const ;
+   //real local_average_density(float sigma = 2.3f, int iCombination = 0) const ;
+   //Vec3r curvature2d_as_vector(int iCombination=0) const ;
+  /*! angle in radians */
+   //real curvature2d_as_angle(int iCombination=0) const ;  
+  
+  /* advanced iterators access */
+  point_iterator points_begin(float step = 0);
+  const_point_iterator points_begin(float step = 0) const;
+  point_iterator points_end(float step = 0);
+  const_point_iterator points_end(float step = 0) const;
+
+  // methods given for convenience */
+  point_iterator vertices_begin();
+  const_point_iterator vertices_begin() const;
+  point_iterator vertices_end();
+  const_point_iterator vertices_end() const;
+
+  // specialized iterators access
+  CurveInternal::CurvePointIterator curvePointsBegin(float t=0.f);
+  CurveInternal::CurvePointIterator curvePointsEnd(float t=0.f);
+
+  CurveInternal::CurvePointIterator curveVerticesBegin();
+  CurveInternal::CurvePointIterator curveVerticesEnd();
+
+  // Iterators access
+  /*! Returns an Interface0DIterator pointing onto
+   *  the first vertex of the Curve and that can iterate
+   *  over the \a vertices of the Curve.
+   */
+  virtual Interface0DIterator verticesBegin();
+  /*! Returns an Interface0DIterator pointing after
+   *  the last vertex of the Curve and that can iterate
+   *  over the \a vertices of the Curve.
+   */
+  virtual Interface0DIterator verticesEnd();
+  /*! Returns an Interface0DIterator pointing onto
+   *  the first point of the Curve and that can iterate
+   *  over the \a points of the Curve at any resolution.
+   *  At each iteration a virtual temporary CurvePoint
+   *  is created.
+   */
+  virtual Interface0DIterator pointsBegin(float t=0.f);
+  /*! Returns an Interface0DIterator pointing after
+   *  the last point of the Curve and that can iterate
+   *  over the \a points of the Curve at any resolution.
+   *  At each iteration a virtual temporary CurvePoint
+   *  is created.
+   */
+  virtual Interface0DIterator pointsEnd(float t=0.f);
+};
+
+  
+
+#endif
diff --git a/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
new file mode 100755
index 00000000000..dfc9f2719f8
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h
@@ -0,0 +1,378 @@
+//
+//  Filename         : CurveAdvancedIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the elements of the Curve
+//                     Can't be used in python
+//  Date of creation : 01/08/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ADVANCEDCURVEITERATORS_H
+# define ADVANCEDCURVEITERATORS_H
+
+# include "Stroke.h"
+
+namespace CurveInternal {
+
+  class CurvePoint_const_traits : public Const_traits<CurvePoint*> {
+  public:
+    typedef deque<CurvePoint*> vertex_container;
+    typedef vertex_container::const_iterator vertex_container_iterator;
+    typedef SVertex vertex_type; 
+  };
+  
+  class CurvePoint_nonconst_traits : public Nonconst_traits<CurvePoint*> {
+  public:
+    typedef deque<CurvePoint*> vertex_container;
+    typedef vertex_container::iterator vertex_container_iterator ;
+    typedef SVertex vertex_type; 
+  };
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*     CurvePoint Iterator        */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+  /*! iterator on a curve. Allows an iterating outside 
+   *  initial vertices. A CurvePoint is instanciated an returned 
+   *  when the iterator is dereferenced.
+   */
+
+  template<class Traits>
+    class __point_iterator : public IteratorBase<Traits, BidirectionalIteratorTag_Traits>
+  { 
+  public:
+    typedef __point_iterator <Traits>  Self;
+    typedef typename Traits::vertex_container_iterator  vertex_container_iterator;
+    typedef typename Traits::vertex_type vertex_type;
+    typedef CurvePoint Point;
+    typedef Point point_type;
+    
+    typedef __point_iterator<CurvePoint_nonconst_traits > iterator;
+    typedef __point_iterator<CurvePoint_const_traits > const_iterator;
+    
+    //  public:
+    //    typedef Vertex vertex_type ;
+    //    typedef vertex_container_iterator vertex_iterator_type;
+    //    typedef CurvePoint<Vertex> Point;
+    //    typedef Point point_type;
+    typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
+    //# if defined(__GNUC__) && (__GNUC__ < 3)
+    //    typedef bidirectional_iterator<CurvePoint<Vertex>,ptrdiff_t> bidirectional_point_iterator;
+    //# else
+    //    typedef iterator<bidirectional_iterator_tag, CurvePoint<Vertex>,ptrdiff_t> bidirectional_point_iterator;
+    //# endif
+    friend class Curve; 
+    //friend class Curve::vertex_iterator;
+    //friend class __point_iterator<CurvePoint_nonconst_traits >;
+    //friend class iterator;
+    //protected:
+  public:
+    float _CurvilinearLength;
+    float _step;
+    vertex_container_iterator __A;
+    vertex_container_iterator __B;
+    vertex_container_iterator _begin;
+    vertex_container_iterator _end;
+    int _n;
+    int _currentn;
+    float _t;
+    mutable Point *_Point;
+    
+  public:
+    
+  public:
+    inline __point_iterator(float step = 0.f)
+      : parent_class()
+    {
+      _step = step;
+      _CurvilinearLength = 0.f;
+      _t = 0.f;
+      _Point = 0;
+      _n = 0;
+      _currentn = 0;
+    }
+    
+    inline __point_iterator(const iterator& iBrother)
+      : parent_class()
+    {
+      __A = iBrother.__A;
+      __B = iBrother.__B;
+      _begin = iBrother._begin;
+      _end = iBrother._end;
+      _CurvilinearLength = iBrother._CurvilinearLength;
+      _step = iBrother._step;
+      _t = iBrother._t;
+      if(iBrother._Point == 0)
+        _Point = 0;
+      else
+        _Point = new Point(*(iBrother._Point));
+      _n = iBrother._n;
+      _currentn = iBrother._currentn;
+    }
+    inline __point_iterator(const const_iterator& iBrother)
+      : parent_class()
+    {
+      __A = iBrother.__A;
+      __B = iBrother.__B;
+      _begin = iBrother._begin;
+      _end = iBrother._end;
+      _CurvilinearLength = iBrother._CurvilinearLength;
+      _step = iBrother._step;
+      _t = iBrother._t;
+      if(iBrother._Point == 0)
+        _Point = 0;
+      else
+        _Point = new Point(*(iBrother._Point));
+      _n = iBrother._n;
+      _currentn = iBrother._currentn;
+    }
+    inline Self& operator=(const Self& iBrother)
+    {
+      //((bidirectional_point_iterator*)this)->operator=(iBrother);
+      __A = iBrother.__A;
+      __B = iBrother.__B;
+      _begin = iBrother._begin;
+      _end = iBrother._end;
+      _CurvilinearLength = iBrother._CurvilinearLength;
+      _step = iBrother._step;
+      _t = iBrother._t;
+      if(iBrother._Point == 0)
+        _Point = 0;
+      else
+        _Point = new Point(*(iBrother._Point));
+      _n = iBrother._n;
+      _currentn = iBrother._currentn;
+      return *this;
+    }
+    virtual ~__point_iterator()
+    {
+      if(_Point != 0)
+        delete _Point;
+    }
+  //protected://FIXME
+  public:
+    inline __point_iterator(vertex_container_iterator iA, 
+      vertex_container_iterator iB, 
+      vertex_container_iterator ibegin, 
+      vertex_container_iterator iend, 
+      int currentn,
+      int n,
+      float step, float t=0.f, float iCurvilinearLength = 0.f)
+      : parent_class()
+    {
+      __A = iA;
+      __B = iB;
+      _begin = ibegin;
+      _end = iend;
+      _CurvilinearLength = iCurvilinearLength;
+      _step = step;
+      _t = t;
+      _Point = 0;
+      _n = n;
+      _currentn = currentn;
+    }
+    
+  public:
+    
+    // operators
+    inline Self& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    inline Self operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    }
+    inline Self& operator--()  // operator corresponding to ++i
+    { 
+      decrement();
+      return *this;
+    }
+    inline Self operator--(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      decrement();                    // dans un temporaire. 
+      return tmp;
+    }
+    
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      return ((__A!=b.__A) || (__B!=b.__B) || (_t != b._t));
+    }
+    virtual bool operator==(const Self& b) const
+    {
+      return !(*this != b);
+    }
+    
+    // dereferencing
+    virtual typename Traits::reference operator*() const  
+    {
+      if(_Point != 0)
+      {
+        delete _Point;
+        _Point = 0;
+      }
+      if((_currentn < 0) || (_currentn >= _n))
+        return _Point; // 0 in this case
+      return (_Point = new Point(*__A,*__B,_t));
+    }
+    virtual typename Traits::pointer operator->() const { return &(operator*());}
+    
+  public:
+    virtual bool begin() const 
+    {
+      if((__A == _begin) && (_t < (float)M_EPSILON))
+        return true;
+      return false;
+    }
+    virtual bool end() const 
+    {
+      if((__B == _end))
+        return true;
+      return false;
+    }
+  protected:
+    virtual void increment() 
+    {
+      if(_Point != 0)
+      {
+        delete _Point;
+        _Point = 0;
+      }
+      if((_currentn == _n-1) && (_t == 1.f))
+      {
+        // we're setting the iterator to end
+        ++__A;
+        ++__B;
+        ++_currentn;
+        _t = 0.f;
+        return;
+      }
+      
+      if(0 == _step) // means we iterate over initial vertices
+      {
+	      Vec3r vec_tmp((*__B)->point2d() - (*__A)->point2d());
+        _CurvilinearLength += vec_tmp.norm();
+        if(_currentn == _n-1)
+        { 
+          _t = 1.f;   
+          return;
+        }
+        ++__B;
+        ++__A;
+        ++_currentn;
+        return;
+      }
+      
+      // compute the new position:
+      Vec3r vec_tmp2((*__A)->point2d() - (*__B)->point2d());
+      float normAB = vec_tmp2.norm();
+
+      if(normAB > M_EPSILON)
+      {
+        _CurvilinearLength += _step;
+        _t = _t + _step/normAB;
+      }
+      else
+        _t = 1.f; // AB is a null segment, we're directly at its end
+        //if normAB ~= 0, we don't change these values
+      if(_t >= 1)
+      { 
+        _CurvilinearLength -= normAB*(_t-1);
+        if(_currentn == _n-1)
+          _t=1.f;
+        else
+        {
+          _t = 0.f;
+          ++_currentn;
+          ++__A;++__B;
+        }
+      }
+    }
+    virtual void decrement() 
+    {
+      if(_Point != 0)
+      {
+        delete _Point;
+        _Point = 0;
+      }
+      
+      if(_t == 0.f) //we're at the beginning of the edge
+      {
+        _t = 1.f;
+        --_currentn;
+        --__A; --__B;
+        if(_currentn == _n-1)
+          return;
+      }
+
+      if(0 == _step) // means we iterate over initial vertices
+      {
+	      Vec3r vec_tmp((*__B)->point2d() - (*__A)->point2d());
+        _CurvilinearLength -= vec_tmp.norm();
+        _t = 0;
+        return;
+      }
+      
+      // compute the new position:
+      Vec3r vec_tmp2((*__A)->point2d() - (*__B)->point2d());
+      float normAB = vec_tmp2.norm();
+      
+      if(normAB >M_EPSILON)
+      {
+        _CurvilinearLength -= _step;
+        _t = _t - _step/normAB;
+      }
+      else
+        _t = -1.f; // We just need a negative value here
+
+      // round value
+      if(fabs(_t) < (float)M_EPSILON)
+        _t = 0.0;
+      if(_t < 0)
+      { 
+        if(_currentn == 0)
+          _CurvilinearLength = 0.f;
+        else
+        _CurvilinearLength += normAB*(-_t);
+        _t = 0.f;
+      } 
+    }
+  };
+
+
+
+} // end of namespace StrokeInternal
+
+
+#endif // ADVANCEDCURVEITERATORS_H
diff --git a/source/blender/freestyle/intern/stroke/CurveIterators.h b/source/blender/freestyle/intern/stroke/CurveIterators.h
new file mode 100755
index 00000000000..92f8bf065f4
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/CurveIterators.h
@@ -0,0 +1,295 @@
+//
+//  Filename         : CurveIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the elements of the Curve
+//  Date of creation : 01/08/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CURVEITERATORS_H
+# define CURVEITERATORS_H
+
+#include "Stroke.h"
+#include "Curve.h"
+
+namespace CurveInternal {
+
+  /*! iterator on a curve. Allows an iterating outside 
+   *  initial vertices. A CurvePoint is instanciated an returned 
+   *  when the iterator is dereferenced.
+   */
+
+  class CurvePointIterator : public Interface0DIteratorNested
+  { 
+  public:
+    friend class ::Curve; 
+  public:
+    float _CurvilinearLength;
+    float _step;
+    ::Curve::vertex_container::iterator __A;
+    ::Curve::vertex_container::iterator __B;
+    ::Curve::vertex_container::iterator _begin;
+    ::Curve::vertex_container::iterator _end;
+    int _n;
+    int _currentn;
+    float _t;
+    mutable CurvePoint _Point;
+    float _CurveLength;
+
+  public:
+    
+  public:
+    inline CurvePointIterator(float step = 0.f)
+      : Interface0DIteratorNested()
+    {
+      _step = step;
+      _CurvilinearLength = 0.f;
+      _t = 0.f;
+      //_Point = 0;
+      _n = 0;
+      _currentn = 0;
+      _CurveLength=0;
+    }
+    
+    inline CurvePointIterator(const CurvePointIterator& iBrother)
+      : Interface0DIteratorNested()
+    {
+      __A = iBrother.__A;
+      __B = iBrother.__B;
+      _begin = iBrother._begin;
+      _end = iBrother._end;
+      _CurvilinearLength = iBrother._CurvilinearLength;
+      _step = iBrother._step;
+      _t = iBrother._t;
+      _Point = iBrother._Point;
+      _n = iBrother._n;
+      _currentn = iBrother._currentn;
+      _CurveLength = iBrother._CurveLength;
+    }
+    inline CurvePointIterator& operator=(const CurvePointIterator& iBrother)
+    {
+      __A = iBrother.__A;
+      __B = iBrother.__B;
+      _begin = iBrother._begin;
+      _end = iBrother._end;
+      _CurvilinearLength = iBrother._CurvilinearLength;
+      _step = iBrother._step;
+      _t = iBrother._t;
+      _Point = iBrother._Point;
+      _n = iBrother._n;
+      _currentn = iBrother._currentn;
+      _CurveLength = iBrother._CurveLength;
+      return *this;
+    }
+    virtual ~CurvePointIterator()
+    {
+    }
+  protected:
+    inline CurvePointIterator(::Curve::vertex_container::iterator iA, 
+                              ::Curve::vertex_container::iterator iB, 
+                              ::Curve::vertex_container::iterator ibegin, 
+                              ::Curve::vertex_container::iterator iend,
+                              int currentn,
+      int n,
+      float iCurveLength,
+      float step, float t=0.f, float iCurvilinearLength = 0.f)
+      : Interface0DIteratorNested()
+    {
+      __A = iA;
+      __B = iB;
+      _begin = ibegin;
+      _end = iend;
+      _CurvilinearLength = iCurvilinearLength;
+      _step = step;
+      _t = t;
+      _n = n;
+      _currentn = currentn;
+      _CurveLength = iCurveLength;
+    }
+ 
+  public:
+
+    virtual CurvePointIterator* copy() const {
+      return new CurvePointIterator(*this);
+    }
+
+    inline Interface0DIterator CastToInterface0DIterator() const{
+      Interface0DIterator ret(new CurveInternal::CurvePointIterator(*this));
+      return ret;
+    }
+    virtual string getExactTypeName() const {
+      return "CurvePointIterator";
+    }
+    
+    // operators
+    inline CurvePointIterator& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+   
+    inline CurvePointIterator& operator--()  // operator corresponding to ++i
+    { 
+      decrement();
+      return *this;
+    }
+    
+    // comparibility
+    virtual bool operator==(const Interface0DIteratorNested& b) const
+    {
+      const CurvePointIterator* it_exact = dynamic_cast<const CurvePointIterator*>(&b);
+      if (!it_exact)
+	  return false;
+      return ((__A==it_exact->__A) && (__B==it_exact->__B) && (_t == it_exact->_t));
+    }
+    
+    // dereferencing
+    virtual CurvePoint& operator*()  
+    {
+      return (_Point = CurvePoint(*__A,*__B,_t));
+    }
+    virtual CurvePoint* operator->() { return &(operator*());}
+  public:
+    virtual bool isBegin() const 
+    {
+      if((__A == _begin) && (_t < (float)M_EPSILON))
+        return true;
+      return false;
+    }
+    virtual bool isEnd() const 
+    {
+      if(__B == _end)
+        return true;
+      return false;
+    }
+  protected:
+    virtual void increment() 
+    {
+      if((_currentn == _n-1) && (_t == 1.f))
+      {
+        // we're setting the iterator to end
+        ++__A;
+        ++__B;
+        ++_currentn;
+        _t = 0.f;
+        return;
+      }
+      
+      if(0 == _step) // means we iterate over initial vertices
+      {
+	      Vec3r vec_tmp((*__B)->point2d() - (*__A)->point2d());
+        _CurvilinearLength += (float)vec_tmp.norm();
+        if(_currentn == _n-1)
+        { 
+          _t = 1.f;   
+          return;
+        }
+        ++__B;
+        ++__A;
+        ++_currentn;
+        return;
+      }
+      
+      // compute the new position:
+      Vec3r vec_tmp2((*__A)->point2d() - (*__B)->point2d());
+      float normAB = (float)vec_tmp2.norm();
+
+      if(normAB > M_EPSILON)
+      {
+        _CurvilinearLength += _step;
+        _t = _t + _step/normAB;
+      }
+      else
+        _t = 1.f; // AB is a null segment, we're directly at its end
+        //if normAB ~= 0, we don't change these values
+      if(_t >= 1)
+      { 
+        _CurvilinearLength -= normAB*(_t-1);
+        if(_currentn == _n-1)
+          _t=1.f;
+        else
+        {
+          _t = 0.f;
+          ++_currentn;
+          ++__A;++__B;
+        }
+      }
+    }
+    virtual void decrement() 
+    {
+      if(_t == 0.f) //we're at the beginning of the edge
+      {
+        _t = 1.f;
+        --_currentn;
+        --__A; --__B;
+        if(_currentn == _n-1)
+          return;
+      }
+
+      if(0 == _step) // means we iterate over initial vertices
+      {
+	      Vec3r vec_tmp((*__B)->point2d() - (*__A)->point2d());
+        _CurvilinearLength -= (float)vec_tmp.norm();
+        _t = 0;
+        return;
+      }
+      
+      // compute the new position:
+      Vec3r vec_tmp2((*__A)->point2d() - (*__B)->point2d());
+      float normAB = (float)vec_tmp2.norm();
+      
+      if(normAB >M_EPSILON)
+      {
+        _CurvilinearLength -= _step;
+        _t = _t - _step/normAB;
+      }
+      else
+        _t = -1.f; // We just need a negative value here
+
+      // round value
+      if(fabs(_t) < (float)M_EPSILON)
+        _t = 0.0;
+      if(_t < 0)
+      { 
+        if(_currentn == 0)
+          _CurvilinearLength = 0.f;
+        else
+        _CurvilinearLength += normAB*(-_t);
+        _t = 0.f;
+      } 
+    }
+
+    virtual float t() const{
+      return _CurvilinearLength;
+    } 
+    virtual float u() const{
+      return _CurvilinearLength/_CurveLength;
+    } 
+  };
+
+  
+
+} // end of namespace StrokeInternal
+
+#endif // CURVEITERATORS_H
diff --git a/source/blender/freestyle/intern/stroke/Modifiers.h b/source/blender/freestyle/intern/stroke/Modifiers.h
new file mode 100755
index 00000000000..21bebebc6f8
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Modifiers.h
@@ -0,0 +1,71 @@
+//
+//  Filename         : Modifiers.h
+//  Author           : Stephane Grabli
+//  Purpose          : modifiers...
+//  Date of creation : 05/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  MODIFIERS_H
+# define MODIFIERS_H
+
+# include "TimeStamp.h"
+
+/* ----------------------------------------- *
+ *                                           *
+ *              modifiers                 *
+ *                                           *
+ * ----------------------------------------- */
+/*! Base class for modifiers.
+ *  Modifiers are used in the
+ *  Operators in order to "mark"
+ *  the processed Interface1D.
+ */
+template<class Edge>
+struct EdgeModifier : public unary_function<Edge,void>
+{
+  /*! Default construction */
+  EdgeModifier() : unary_function<Edge,void>() {}
+  /*! the () operator */
+  virtual void operator()(Edge& iEdge) {}
+};
+
+/*! Modifier that sets the time stamp
+ *  of an Interface1D to the time stamp
+ *  of the system.
+ */
+template<class Edge>
+struct TimestampModifier : public EdgeModifier<Edge>
+{
+  /*! Default constructor */
+  TimestampModifier() : EdgeModifier<Edge>() {}
+  /*! The () operator. */
+  virtual void operator()(Edge& iEdge) 
+  {
+    TimeStamp *timestamp = TimeStamp::instance();
+    iEdge.setTimeStamp(timestamp->getTimeStamp());
+  }
+};
+
+#endif // MODIFIERS_H
diff --git a/source/blender/freestyle/intern/stroke/Module.h b/source/blender/freestyle/intern/stroke/Module.h
new file mode 100755
index 00000000000..591bb157392
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Module.h
@@ -0,0 +1,72 @@
+//
+//  Filename         : Module.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Set the type of the module
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  MODULE_H
+# define MODULE_H
+
+# include "Canvas.h"
+# include "StyleModule.h"
+
+class Module
+{
+public:
+
+  static void setAlwaysRefresh(bool b = true) {
+    getCurrentStyleModule()->setAlwaysRefresh(b);
+  }
+
+  static void setCausal(bool b = true) {
+    getCurrentStyleModule()->setCausal(b);
+  }
+
+  static void setDrawable(bool b = true) {
+    getCurrentStyleModule()->setDrawable(b);
+  }
+
+  static bool getAlwaysRefresh() {
+    return getCurrentStyleModule()->getAlwaysRefresh();
+  }
+
+  static bool getCausal() {
+    return getCurrentStyleModule()->getCausal();
+  }
+
+  static bool getDrawable() {
+    return getCurrentStyleModule()->getDrawable();
+  }
+
+private:
+
+  static StyleModule* getCurrentStyleModule() {
+    Canvas* canvas = Canvas::getInstance();
+    return canvas->getCurrentStyleModule();
+  }
+};
+
+#endif // MODULE_H
diff --git a/source/blender/freestyle/intern/stroke/Operators.cpp b/source/blender/freestyle/intern/stroke/Operators.cpp
new file mode 100755
index 00000000000..cfdd72ac839
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Operators.cpp
@@ -0,0 +1,862 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <algorithm>
+#include "Operators.h"
+#include "Canvas.h"
+#include "Stroke.h"
+
+LIB_STROKE_EXPORT Operators::I1DContainer	  Operators::_current_view_edges_set;
+LIB_STROKE_EXPORT Operators::I1DContainer		Operators::_current_chains_set;
+LIB_STROKE_EXPORT Operators::I1DContainer*	Operators::_current_set = NULL;
+LIB_STROKE_EXPORT Operators::StrokesContainer	Operators::_current_strokes_set;
+
+void Operators::select(UnaryPredicate1D& pred) {
+  if (!_current_set)
+    return;
+  if(_current_set->empty())
+    return;
+  I1DContainer new_set;
+  I1DContainer rejected;
+  Functions1D::ChainingTimeStampF1D cts;
+  Functions1D::TimeStampF1D ts;
+  I1DContainer::iterator it = _current_set->begin();
+  I1DContainer::iterator itbegin = it;
+  while (it != _current_set->end()) {
+    Interface1D * i1d = *it;
+    cts(*i1d); // mark everyone's chaining time stamp anyway
+    if (pred(*i1d)){
+      new_set.push_back(i1d);
+      ts(*i1d);
+    }else{
+      rejected.push_back(i1d);
+    }
+    ++it;
+  }
+  if((*itbegin)->getExactTypeName() != "ViewEdge"){
+    for (it = rejected.begin();
+       it != rejected.end();
+       ++it)
+    delete *it;
+  }
+  rejected.clear();
+  _current_set->clear();
+  *_current_set = new_set;
+}
+
+
+void Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
+		      UnaryPredicate1D& pred,
+		      UnaryFunction1D<void>& modifier) {
+  if (_current_view_edges_set.empty())
+    return;
+
+  unsigned id = 0;
+  ViewEdge* edge;
+  //soc unused - Chain* new_chain;
+
+  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+       it_edge != _current_view_edges_set.end();
+       ++it_edge) {
+    if (pred(**it_edge))
+      continue;
+
+    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+
+    Chain* new_chain = new Chain(id);++id;
+    do {
+      new_chain->push_viewedge_back(*it, it.getOrientation());
+      modifier(**it);
+      ++it;
+    } while (!it.isEnd() && !pred(**it));
+
+    _current_chains_set.push_back(new_chain);
+  }
+
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+
+void Operators::chain(ViewEdgeInternal::ViewEdgeIterator& it,
+		      UnaryPredicate1D& pred) {
+  if (_current_view_edges_set.empty())
+    return;
+
+  unsigned id = 0;
+  Functions1D::IncrementChainingTimeStampF1D ts;
+  Predicates1D::EqualToChainingTimeStampUP1D pred_ts(TimeStamp::instance()->getTimeStamp()+1);
+
+  ViewEdge* edge;
+  //soc Chain* new_chain;
+
+  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+       it_edge != _current_view_edges_set.end();
+       ++it_edge) {
+    if (pred(**it_edge) || pred_ts(**it_edge))
+      continue;
+
+    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+
+    Chain* new_chain = new Chain(id);++id;
+    do {
+      new_chain->push_viewedge_back(*it, it.getOrientation());
+      ts(**it);
+      ++it;
+    } while (!it.isEnd() && !pred(**it) && !pred_ts(**it));
+
+    _current_chains_set.push_back(new_chain);
+  }
+
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+
+//void Operators::bidirectionalChain(ViewEdgeIterator& it,
+//				   UnaryPredicate1D& pred,
+//				   UnaryFunction1D<void>& modifier) {
+//  if (_current_view_edges_set.empty())
+//    return;
+//
+//  unsigned id = 0;
+//  ViewEdge* edge;
+//  Chain* new_chain;
+//
+//  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+//       it_edge != _current_view_edges_set.end();
+//       ++it_edge) {
+//    if (pred(**it_edge))
+//      continue;
+//
+//    edge = dynamic_cast<ViewEdge*>(*it_edge);
+//    it.setBegin(edge);
+//    it.setCurrentEdge(edge);
+//
+//    Chain* new_chain = new Chain(id);++id;
+//    //ViewEdgeIterator it_back(it);--it_back; // FIXME
+//    do {
+//      new_chain->push_viewedge_back(*it, it.getOrientation());
+//      modifier(**it);
+//      ++it;
+//    } while (!it.isEnd() && !pred(**it));
+//    it.setBegin(edge);
+//    it.setCurrentEdge(edge);
+//    --it;
+//    while (!it.isEnd() && !pred(**it)) {
+//      new_chain->push_viewedge_front(*it, it.getOrientation());
+//      modifier(**it);
+//      --it;
+//    }
+//
+//    _current_chains_set.push_back(new_chain);
+//  }
+//
+//  if (!_current_chains_set.empty())
+//    _current_set = &_current_chains_set;
+//}
+//
+//void Operators::bidirectionalChain(ViewEdgeIterator& it,
+//				   UnaryPredicate1D& pred) {
+//  if (_current_view_edges_set.empty())
+//    return;
+//
+//  unsigned id = 0;
+//  Functions1D::IncrementChainingTimeStampF1D ts;
+//  Predicates1D::EqualToChainingTimeStampUP1D pred_ts(TimeStamp::instance()->getTimeStamp()+1);
+//
+//  ViewEdge* edge;
+//  Chain* new_chain;
+//
+//  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+//       it_edge != _current_view_edges_set.end();
+//       ++it_edge) {
+//    if (pred(**it_edge) || pred_ts(**it_edge))
+//      continue;
+//
+//    edge = dynamic_cast<ViewEdge*>(*it_edge);
+//    it.setBegin(edge);
+//    it.setCurrentEdge(edge);
+          //
+          //    Chain* new_chain = new Chain(id);++id;
+          //    //ViewEdgeIterator it_back(it);--it_back;//FIXME
+          //    do {
+          //      new_chain->push_viewedge_back(*it, it.getOrientation());
+          //      ts(**it);
+          //      ++it;
+          //    } while (!it.isEnd() && !pred(**it) && !pred_ts(**it));
+          //    it.setBegin(edge);
+          //    it.setCurrentEdge(edge);
+          //    --it;
+          //    while (!it.isEnd() && !pred(**it) && !pred_ts(**it)) {
+          //      new_chain->push_viewedge_front(*it, it.getOrientation());
+          //      ts(**it);
+          //      --it;
+          //    }
+          //
+          //    _current_chains_set.push_back(new_chain);
+          //  }
+          //
+          //  if (!_current_chains_set.empty())
+          //    _current_set = &_current_chains_set;
+          //}
+
+void Operators::bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred) {
+  if (_current_view_edges_set.empty())
+    return;
+
+  unsigned id = 0;
+  Functions1D::IncrementChainingTimeStampF1D ts;
+  Predicates1D::EqualToChainingTimeStampUP1D pred_ts(TimeStamp::instance()->getTimeStamp()+1);
+  
+  ViewEdge* edge;
+  //soc unused - Chain* new_chain;
+  
+  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+  it_edge != _current_view_edges_set.end();
+  ++it_edge) {
+    if (pred(**it_edge) || pred_ts(**it_edge))
+      continue;
+    
+    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    // re-init iterator
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+    it.setOrientation(true);
+    it.init();
+    
+    Chain* new_chain = new Chain(id);++id;
+    //ViewEdgeIterator it_back(it);--it_back;//FIXME
+    do {
+      new_chain->push_viewedge_back(*it, it.getOrientation());
+      ts(**it);
+      it.increment(); // FIXME
+    } while (!it.isEnd() && !pred(**it));
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+    it.setOrientation(true);
+    it.decrement(); // FIXME
+    while (!it.isEnd() && !pred(**it)) {
+      new_chain->push_viewedge_front(*it, it.getOrientation());
+      ts(**it);
+      it.decrement();// FIXME
+    }
+    _current_chains_set.push_back(new_chain);
+  }
+  
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+void Operators::bidirectionalChain(ChainingIterator& it) {
+  if (_current_view_edges_set.empty())
+    return;
+
+  unsigned id = 0;
+  Functions1D::IncrementChainingTimeStampF1D ts;
+  Predicates1D::EqualToChainingTimeStampUP1D pred_ts(TimeStamp::instance()->getTimeStamp()+1);
+  
+  ViewEdge* edge;
+  //soc unused - Chain* new_chain;
+  
+  for (I1DContainer::iterator it_edge = _current_view_edges_set.begin();
+  it_edge != _current_view_edges_set.end();
+  ++it_edge) {
+    if (pred_ts(**it_edge))
+      continue;
+    
+    edge = dynamic_cast<ViewEdge*>(*it_edge);
+    // re-init iterator
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+    it.setOrientation(true);
+    it.init();
+    
+    Chain* new_chain = new Chain(id);++id;
+    //ViewEdgeIterator it_back(it);--it_back;//FIXME
+    do {
+      new_chain->push_viewedge_back(*it, it.getOrientation());
+      ts(**it);
+      it.increment(); // FIXME
+    } while (!it.isEnd());
+    it.setBegin(edge);
+    it.setCurrentEdge(edge);
+    it.setOrientation(true);
+    it.decrement(); // FIXME
+    while (!it.isEnd()) {
+      new_chain->push_viewedge_front(*it, it.getOrientation());
+      ts(**it);
+      it.decrement();// FIXME
+    }
+    _current_chains_set.push_back(new_chain);
+  }
+  
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+void Operators::sequentialSplit(UnaryPredicate0D& pred, 
+				float sampling)
+{
+  if (_current_chains_set.empty()) {
+    cerr << "Warning: current set empty" << endl;
+    return;
+  }
+  CurvePoint *point;
+  Chain * new_curve;
+  I1DContainer splitted_chains;
+  Interface0DIterator first;
+  Interface0DIterator end;
+  Interface0DIterator last;
+  Interface0DIterator it;
+  I1DContainer::iterator cit = _current_chains_set.begin(), citend = _current_chains_set.end();
+  for (;
+       cit != citend;
+       ++cit) {
+    
+    Id currentId = (*cit)->getId();
+    new_curve = new Chain(currentId);
+    first = (*cit)->pointsBegin(sampling);
+    end = (*cit)->pointsEnd(sampling);
+    last = end;--last;
+    it = first;
+
+    point = dynamic_cast<CurvePoint*>(&(*it));
+    new_curve->push_vertex_back(point);++it;
+    for(; it!= end; ++it)
+      {
+        point = dynamic_cast<CurvePoint*>(&(*it));
+        new_curve->push_vertex_back(point);
+        if((pred(it)) && (it!=last))
+          {
+            splitted_chains.push_back(new_curve);
+            currentId.setSecond(currentId.getSecond()+1);
+            new_curve = new Chain(currentId);
+            new_curve->push_vertex_back(point);
+          }
+      }
+    if(new_curve->nSegments() == 0){
+      delete new_curve;
+      return;
+    }
+
+    splitted_chains.push_back(new_curve);
+  }
+
+  // Update the current set of chains:
+  cit = _current_chains_set.begin();
+  for(;
+      cit != citend;
+      ++cit){
+    delete (*cit);
+  }
+  _current_chains_set.clear();
+  _current_chains_set = splitted_chains;
+  splitted_chains.clear();
+
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+void Operators::sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, 
+				float sampling)
+{
+  if (_current_chains_set.empty()) {
+    cerr << "Warning: current set empty" << endl;
+    return;
+  }
+  CurvePoint *point;
+  Chain * new_curve;
+  I1DContainer splitted_chains;
+  Interface0DIterator first;
+  Interface0DIterator end;
+  Interface0DIterator last;
+  Interface0DIterator itStart;
+  Interface0DIterator itStop;
+  I1DContainer::iterator cit = _current_chains_set.begin(), citend = _current_chains_set.end();
+  for (;
+  cit != citend;
+  ++cit) {
+    Id currentId = (*cit)->getId();
+    first = (*cit)->pointsBegin(sampling);
+    end = (*cit)->pointsEnd(sampling);
+    last = end;--last;
+    itStart = first;
+    do{
+      itStop = itStart;++itStop;
+      
+      new_curve = new Chain(currentId);
+      currentId.setSecond(currentId.getSecond()+1);
+      
+      point = dynamic_cast<CurvePoint*>(&(*itStart));
+      new_curve->push_vertex_back(point);    
+      do{
+        point = dynamic_cast<CurvePoint*>(&(*itStop));
+        new_curve->push_vertex_back(point);    
+        ++itStop;
+      }while((itStop!=end) && (!stoppingPred(itStop)));
+      if(itStop!=end){
+        point = dynamic_cast<CurvePoint*>(&(*itStop));
+        new_curve->push_vertex_back(point);    
+      }
+      if(new_curve->nSegments() == 0){
+        delete new_curve;
+      }else{
+        splitted_chains.push_back(new_curve);
+      }
+      // find next start
+      do{
+        ++itStart;
+      }while((itStart!=end) && (!startingPred(itStart)));
+    }while((itStart!=end) && (itStart!=last));
+  }
+  
+  // Update the current set of chains:
+  cit = _current_chains_set.begin();
+  for(;
+  cit != citend;
+  ++cit){
+    delete (*cit);
+  }
+  _current_chains_set.clear();
+  _current_chains_set = splitted_chains;
+  splitted_chains.clear();
+  
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+#include "CurveIterators.h"
+
+// Internal function
+void __recursiveSplit(Chain *_curve, UnaryFunction0D<double>& func, UnaryPredicate1D& pred, float sampling,
+                      Operators::I1DContainer& newChains, Operators::I1DContainer& splitted_chains)
+{
+  if(((_curve->nSegments() == 1) && (sampling == 0)) || (_curve->getLength2D() <= sampling)){
+    newChains.push_back(_curve);
+    return;
+  }
+
+  CurveInternal::CurvePointIterator first             = _curve->curvePointsBegin(sampling);
+  CurveInternal::CurvePointIterator second            = first; ++second;
+  CurveInternal::CurvePointIterator end               = _curve->curvePointsEnd(sampling);
+  CurveInternal::CurvePointIterator it                = second;
+  CurveInternal::CurvePointIterator split             = second;
+  Interface0DIterator it0d                            = it.CastToInterface0DIterator();
+  real _min                                           = FLT_MAX;++it;//func(it0d);++it;
+  CurveInternal::CurvePointIterator next              = it;++next;
+  real tmp;
+  
+  bool bsplit = false;
+  for(; ((it != end) && (next != end)); ++it,++next){
+    it0d = it.CastToInterface0DIterator();
+    tmp = func(it0d);
+    if(tmp < _min){
+      _min = tmp;
+      split = it;
+      bsplit = true;
+    }
+  }
+  
+  if(!bsplit){ // we didn't find any minimum
+    newChains.push_back(_curve);
+    return;
+  }
+
+  // retrieves the current splitting id
+  Id * newId = _curve->getSplittingId();
+  if(newId == 0){
+    newId = new Id(_curve->getId());
+    _curve->setSplittingId(newId);
+  } 
+
+  Chain *new_curve_a = new Chain(*newId);
+  newId->setSecond(newId->getSecond()+1);
+  new_curve_a->setSplittingId(newId);
+  Chain *new_curve_b = new Chain(*newId);
+  newId->setSecond(newId->getSecond()+1);
+  new_curve_b->setSplittingId(newId);
+  
+  CurveInternal::CurvePointIterator vit = _curve->curveVerticesBegin(), vitend=_curve->curveVerticesEnd();
+  CurveInternal::CurvePointIterator vnext = vit; ++vnext;
+
+  
+  for(; (vit!=vitend)&&(vnext!=vitend)&&(split._CurvilinearLength-vit._CurvilinearLength> 0.001); ++vit,++vnext){
+    new_curve_a->push_vertex_back(&(*vit));
+  }
+  if((vit==vitend) || (vnext == vitend)){
+    cout << "The split takes place in bad location" << endl;
+    newChains.push_back(_curve);
+    delete new_curve_a;
+    delete new_curve_b;
+    return;
+  }
+
+  // build the two resulting chains
+  if(fabs(vit._CurvilinearLength-split._CurvilinearLength) > 0.001){
+    new_curve_a->push_vertex_back(&(*split));
+    new_curve_b->push_vertex_back(&(*split));
+  }
+  else{
+    new_curve_a->push_vertex_back(&(*vit));
+  }
+
+  for(;vit!=vitend;++vit)
+    new_curve_b->push_vertex_back(&(*vit));
+  
+  // let's check whether one or two of the two new curves 
+  // satisfy the stopping condition or not.
+  // (if one of them satisfies it, we don't split)
+  if((pred(*new_curve_a)) || (pred(*new_curve_b))){
+    // we don't actually create these two chains
+    newChains.push_back(_curve);
+    delete new_curve_a;
+    delete new_curve_b;
+    return;
+  }
+  // here we know we'll split _curve:
+  splitted_chains.push_back(_curve);
+
+  __recursiveSplit(new_curve_a, func, pred, sampling, newChains, splitted_chains);
+  __recursiveSplit(new_curve_b, func, pred, sampling, newChains, splitted_chains);
+}
+
+void Operators::recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate1D& pred, float sampling)
+{
+  if (_current_chains_set.empty()) {
+    cerr << "Warning: current set empty" << endl;
+    return;
+  }
+
+  Chain *currentChain = 0;
+  I1DContainer splitted_chains;
+  I1DContainer newChains;
+  I1DContainer::iterator cit = _current_chains_set.begin(), citend = _current_chains_set.end();
+  for (;
+       cit != citend;
+       ++cit) {
+    currentChain = dynamic_cast<Chain*>(*cit);
+    if(!currentChain)
+      continue;
+    // let's check the first one:
+    if(!pred(*currentChain)){
+      __recursiveSplit(currentChain, func, pred, sampling, newChains, splitted_chains);
+    }else{
+      newChains.push_back(currentChain);
+    }
+  }
+  // Update the current set of chains:
+  if(!splitted_chains.empty()){
+    for(cit = splitted_chains.begin(), citend = splitted_chains.end();
+        cit != citend;
+        ++cit){
+      delete (*cit);
+    } 
+  splitted_chains.clear();
+  } 
+  
+  _current_chains_set.clear();
+  _current_chains_set = newChains;
+  newChains.clear();
+
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+
+
+// recursive split with pred 0D
+void __recursiveSplit(Chain *_curve, UnaryFunction0D<double>& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling,
+                      Operators::I1DContainer& newChains, Operators::I1DContainer& splitted_chains)
+{
+  if(((_curve->nSegments() == 1) && (sampling == 0)) || (_curve->getLength2D() <= sampling)){
+    newChains.push_back(_curve);
+    return;
+  }
+
+  CurveInternal::CurvePointIterator first             = _curve->curvePointsBegin(sampling);
+  CurveInternal::CurvePointIterator second            = first; ++second;
+  CurveInternal::CurvePointIterator end               = _curve->curvePointsEnd(sampling);
+  CurveInternal::CurvePointIterator it                = second;
+  CurveInternal::CurvePointIterator split             = second;
+  Interface0DIterator it0d                            = it.CastToInterface0DIterator();
+  //real _min                                           = func(it0d);++it;
+  real _min                                           = FLT_MAX;++it;
+  real mean                                           = 0.f;
+  //soc unused - real variance                                       = 0.f;
+  unsigned count                                      = 0;
+  CurveInternal::CurvePointIterator next              = it;++next;
+  real tmp;
+  
+  bool bsplit = false;
+  for(; ((it != end) && (next != end)); ++it,++next){
+    ++count;
+    it0d = it.CastToInterface0DIterator();
+    if(!pred0d(it0d))
+      continue;
+    tmp = func(it0d);
+    mean += tmp;
+    if(tmp < _min){
+      _min = tmp;
+      split = it;
+      bsplit = true;
+    }
+  }
+  mean /= (float)count;
+
+  //if((!bsplit) || (mean-_min>mean)){ // we didn't find any minimum
+  if(!bsplit){ // we didn't find any minimum
+    newChains.push_back(_curve);
+    return;
+  }
+
+  // retrieves the current splitting id
+  Id * newId = _curve->getSplittingId();
+  if(newId == 0){
+    newId = new Id(_curve->getId());
+    _curve->setSplittingId(newId);
+  } 
+
+  Chain *new_curve_a = new Chain(*newId);
+  newId->setSecond(newId->getSecond()+1);
+  new_curve_a->setSplittingId(newId);
+  Chain *new_curve_b = new Chain(*newId);
+  newId->setSecond(newId->getSecond()+1);
+  new_curve_b->setSplittingId(newId);
+  
+  CurveInternal::CurvePointIterator vit = _curve->curveVerticesBegin(), vitend=_curve->curveVerticesEnd();
+  CurveInternal::CurvePointIterator vnext = vit; ++vnext;
+
+  
+  for(; (vit!=vitend)&&(vnext!=vitend)&&(split._CurvilinearLength-vit._CurvilinearLength> 0.001); ++vit,++vnext){
+    new_curve_a->push_vertex_back(&(*vit));
+  }
+  if((vit==vitend) || (vnext == vitend)){
+    cout << "The split takes place in bad location" << endl;
+    newChains.push_back(_curve);
+    delete new_curve_a;
+    delete new_curve_b;
+    return;
+  }
+
+  // build the two resulting chains
+  if(fabs(vit._CurvilinearLength-split._CurvilinearLength) > 0.001){
+    new_curve_a->push_vertex_back(&(*split));
+    new_curve_b->push_vertex_back(&(*split));
+  }
+  else{
+    new_curve_a->push_vertex_back(&(*vit));
+  }
+
+  for(;vit!=vitend;++vit)
+    new_curve_b->push_vertex_back(&(*vit));
+  
+  // let's check whether one or two of the two new curves 
+  // satisfy the stopping condition or not.
+  // (if one of them satisfies it, we don't split)
+  if((pred(*new_curve_a)) || (pred(*new_curve_b))){
+    // we don't actually create these two chains
+    newChains.push_back(_curve);
+    delete new_curve_a;
+    delete new_curve_b;
+    return;
+  }
+  // here we know we'll split _curve:
+  splitted_chains.push_back(_curve);
+
+  __recursiveSplit(new_curve_a, func, pred0d, pred, sampling, newChains, splitted_chains);
+  __recursiveSplit(new_curve_b, func, pred0d, pred, sampling, newChains, splitted_chains);
+}
+
+void Operators::recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate0D& pred0d,  UnaryPredicate1D& pred, float sampling)
+{
+  if (_current_chains_set.empty()) {
+    cerr << "Warning: current set empty" << endl;
+    return;
+  }
+
+  Chain *currentChain = 0;
+  I1DContainer splitted_chains;
+  I1DContainer newChains;
+  I1DContainer::iterator cit = _current_chains_set.begin(), citend = _current_chains_set.end();
+  for (;
+       cit != citend;
+       ++cit) {
+    currentChain = dynamic_cast<Chain*>(*cit);
+    if(!currentChain)
+      continue;
+    // let's check the first one:
+    if(!pred(*currentChain)){
+      __recursiveSplit(currentChain, func, pred0d, pred, sampling, newChains, splitted_chains);
+    }else{
+      newChains.push_back(currentChain);
+    }
+  }
+  // Update the current set of chains:
+  if(!splitted_chains.empty()){
+    for(cit = splitted_chains.begin(), citend = splitted_chains.end();
+        cit != citend;
+        ++cit){
+      delete (*cit);
+    } 
+  splitted_chains.clear();
+  } 
+  
+  _current_chains_set.clear();
+  _current_chains_set = newChains;
+  newChains.clear();
+
+  if (!_current_chains_set.empty())
+    _current_set = &_current_chains_set;
+}
+// Internal class
+class PredicateWrapper
+{
+public:
+
+  inline PredicateWrapper(BinaryPredicate1D& pred) {
+    _pred = &pred;
+  }
+
+  inline bool operator()(Interface1D* i1, Interface1D* i2) {
+    return (*_pred)(*i1, *i2);
+  }
+
+private:
+
+  BinaryPredicate1D* _pred;
+};
+
+void Operators::sort(BinaryPredicate1D& pred) {
+  if (!_current_set)
+    return;
+  std::sort(_current_set->begin(), _current_set->end(), PredicateWrapper(pred));
+}
+
+Stroke* createStroke(Interface1D& inter) {
+  Stroke* stroke = new Stroke;
+  stroke->setId(inter.getId());
+
+  float currentCurvilignAbscissa = 0.f;
+
+  Interface0DIterator it = inter.verticesBegin(), itend = inter.verticesEnd();
+  Interface0DIterator itfirst = it;
+
+  Vec3r current(it->getProjectedX(), it->getProjectedY(), it->getProjectedZ());
+  Vec3r previous = current;
+  SVertex* sv;
+  CurvePoint* cp;
+  StrokeVertex* stroke_vertex = NULL;  
+
+  do {
+    cp = dynamic_cast<CurvePoint*>(&(*it));
+    if (!cp) {
+      sv = dynamic_cast<SVertex*>(&(*it));
+      if (!sv) {
+	cerr << "Warning: unexpected Vertex type" << endl;
+	continue;
+      }
+      stroke_vertex = new StrokeVertex(sv);
+    }
+    else
+      stroke_vertex = new StrokeVertex(cp);
+    current = stroke_vertex->point2d();
+    Vec3r vec_tmp(current - previous);
+    currentCurvilignAbscissa += vec_tmp.norm();
+    stroke_vertex->setCurvilinearAbscissa(currentCurvilignAbscissa);
+    stroke->push_back(stroke_vertex);
+    previous = current;
+    ++it;
+  } while((it != itend) && (it != itfirst));
+
+  if (it == itfirst) {
+    // Add last vertex:
+    cp = dynamic_cast<CurvePoint*>(&(*it));
+    if (!cp) {
+      sv = dynamic_cast<SVertex*>(&(*it));
+      if (!sv)
+	cerr << "Warning: unexpected Vertex type" << endl;
+      else
+	stroke_vertex = new StrokeVertex(sv);
+    }
+    else
+      stroke_vertex = new StrokeVertex(cp);
+    current = stroke_vertex->point2d();
+    Vec3r vec_tmp(current - previous);
+    currentCurvilignAbscissa += vec_tmp.norm();
+    stroke_vertex->setCurvilinearAbscissa(currentCurvilignAbscissa);
+    stroke->push_back(stroke_vertex);
+  }
+  stroke->setLength(currentCurvilignAbscissa);
+  return stroke;
+}
+
+
+inline void applyShading(Stroke& stroke, vector<StrokeShader*>& shaders) {
+  for (vector<StrokeShader*>::iterator it = shaders.begin();
+       it != shaders.end();
+       ++it)
+    (*it)->shade(stroke);
+}
+
+
+void Operators::create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders) {
+  Canvas* canvas = Canvas::getInstance();
+  if (!_current_set) {
+    cerr << "Warning: current set empty" << endl;
+    return;
+  }
+  for (Operators::I1DContainer::iterator it = _current_set->begin();
+       it != _current_set->end();
+       ++it) {
+    if (!pred(**it))
+      continue;
+    Stroke* stroke = createStroke(**it);
+    if (stroke) {
+      applyShading(*stroke, shaders);
+      canvas->RenderStroke(stroke);
+      _current_strokes_set.push_back(stroke);
+    }
+  }
+}
+
+
+void Operators::reset() {
+  ViewMap* vm = ViewMap::getInstance();
+  if (!vm) {
+    cerr << "Error: no ViewMap computed yet" << endl;
+    return;
+  }
+  _current_view_edges_set.clear();
+  for (I1DContainer::iterator it = _current_chains_set.begin();
+       it != _current_chains_set.end();
+       ++it)
+    delete *it;
+  _current_chains_set.clear();
+  _current_view_edges_set.insert(_current_view_edges_set.begin(),
+				 vm->ViewEdges().begin(),
+				 vm->ViewEdges().end());
+  _current_set = &_current_view_edges_set;
+  _current_strokes_set.clear();
+}
diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h
new file mode 100755
index 00000000000..96ecd0aa75b
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Operators.h
@@ -0,0 +1,311 @@
+//
+//  Filename         : Operators.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class gathering stroke creation algorithms
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  OPERATORS_H
+# define OPERATORS_H
+
+# include <vector>
+# include <iostream>
+# include "../view_map/Interface1D.h"
+# include "Predicates1D.h"
+# include "Predicates0D.h"
+# include "../view_map/ViewMap.h"
+# include "Chain.h"
+# include "ChainingIterators.h"
+# include "../system/TimeStamp.h"
+# include "StrokeShader.h"
+
+/*! Class defining the operators used in a style module.
+ *  There are 4 classes of operators: Selection, Chaining,
+ * Splitting and Creating. All these operators are user controlled
+ * in the scripting language through Functors, Predicates and Shaders
+ * that are taken as arguments.
+ */
+class LIB_STROKE_EXPORT Operators {
+
+public:
+
+  typedef vector<Interface1D*>	I1DContainer;
+  typedef vector<Stroke*>	StrokesContainer;
+
+
+  //
+  // Operators
+  //
+  ////////////////////////////////////////////////
+
+  /*! Selects the ViewEdges of the ViewMap verifying
+   *  a specified condition.
+   *  \param pred The predicate expressing this condition
+   */
+  static void select(UnaryPredicate1D& pred);
+
+  /*! Builds a set of chains from the current set of ViewEdges.
+   *  Each ViewEdge of the current list starts a new chain. The chaining
+   *  operator then iterates over the ViewEdges of the ViewMap using the
+   *  user specified iterator.
+   *  This operator only iterates using the increment operator and is
+   *  therefore unidirectional.
+   *  \param it
+   *           The iterator on the ViewEdges of the ViewMap. It contains
+   *           the chaining rule.
+   *  \param pred
+   *           The predicate on the ViewEdge that expresses the stopping
+   *           condition.
+   *  \param modifier
+   *           A function that takes a ViewEdge as argument and that
+   *           is used to modify the processed ViewEdge state (the timestamp
+   *           incrementation is a typical illustration of such a modifier)
+   */
+  static void chain(ViewEdgeInternal::ViewEdgeIterator& it,
+		    UnaryPredicate1D& pred,
+		    UnaryFunction1D<void>& modifier);
+
+  /*! Builds a set of chains from the current set of ViewEdges.
+   *  Each ViewEdge of the current list starts a new chain. The chaining
+   *  operator then iterates over the ViewEdges of the ViewMap using the
+   *  user specified iterator.
+   *  This operator only iterates using the increment operator and is
+   *  therefore unidirectional.
+   *  This chaining operator is different from the previous one because
+   *  it doesn't take any modifier as argument. Indeed, the time stamp (insuring
+   *  that a ViewEdge is processed one time) is automatically managed in this case.
+   *  \param it
+   *           The iterator on the ViewEdges of the ViewMap. It contains
+   *           the chaining rule.
+   *  \param pred
+   *           The predicate on the ViewEdge that expresses the stopping
+   *           condition.
+   */
+  static void chain(ViewEdgeInternal::ViewEdgeIterator& it,
+		    UnaryPredicate1D& pred);  
+
+  /*! Builds a set of chains from the current set of ViewEdges.
+   *  Each ViewEdge of the current list potentially starts a new chain. The chaining
+   *  operator then iterates over the ViewEdges of the ViewMap using the
+   *  user specified iterator.
+   *  This operator iterates both using the increment and decrement operators and is
+   *  therefore bidirectional.
+   *  This operator works with a ChainingIterator which contains the  
+   *  chaining rules. It is this last one which can be told 
+   *  to chain only edges that belong to the selection or not to 
+   *  process twice a ViewEdge during the chaining.
+   *  Each time a ViewEdge is added to a chain, its chaining time stamp
+   *  is incremented. This allows you to keep track of 
+   *  the number of chains to which a ViewEdge belongs to.
+   *  \param it
+   *           The ChainingIterator on the ViewEdges of the ViewMap. It contains
+   *           the chaining rule.
+   *  \param pred
+   *           The predicate on the ViewEdge that expresses the stopping
+   *           condition.
+   */
+  static void bidirectionalChain(ChainingIterator& it, UnaryPredicate1D& pred);
+
+  /*! The only difference with the above bidirectional chaining algorithm is 
+   *  that we don't need to pass a stopping criterion. This might be desirable 
+   *  when the stopping criterion is already contained in the iterator 
+   *  definition.
+   *  Builds a set of chains from the current set of ViewEdges.
+   *  Each ViewEdge of the current list potentially starts a new chain. The chaining
+   *  operator then iterates over the ViewEdges of the ViewMap using the
+   *  user specified iterator.
+   *  This operator iterates both using the increment and decrement operators and is
+   *  therefore bidirectional.
+   *  This operator works with a ChainingIterator which contains the  
+   *  chaining rules. It is this last one which can be told 
+   *  to chain only edges that belong to the selection or not to 
+   *  process twice a ViewEdge during the chaining.
+   *  Each time a ViewEdge is added to a chain, its chaining time stamp
+   *  is incremented. This allows you to keep track of 
+   *  the number of chains to which a ViewEdge belongs to.
+   *  \param it
+   *           The ChainingIterator on the ViewEdges of the ViewMap. It contains
+   *           the chaining rule.
+   */
+  static void bidirectionalChain(ChainingIterator& it);
+
+  /*! Splits each chain of the current set of chains in a sequential way.
+   *  The points of each chain are processed (with a specified sampling) sequentially.
+   *  Each time a user specified starting condition is verified, a new chain begins and 
+   *  ends as soon as a user-defined stopping predicate is verified.
+   *  This allows chains overlapping rather than chains partitioning.
+   *  The first point of the initial chain is the first point of one of the 
+   *  resulting chains.
+   *  The splitting ends when no more chain can start.
+   *  \param startingPred
+   *           The predicate on a point that expresses the starting
+   *           condition
+   *  \param stoppingPred
+   *           The predicate on a point that expresses the stopping
+   *           condition
+   *  \param sampling
+   *           The resolution used to sample the chain for the predicates
+   *           evaluation. (The chain is not actually resampled, a virtual point
+   *           only progresses along the curve using this resolution)
+   */
+  static void sequentialSplit(UnaryPredicate0D& startingPred, UnaryPredicate0D& stoppingPred, 
+                              float sampling = 0.f);
+
+  /*! Splits each chain of the current set of chains in a sequential way.
+   *  The points of each chain are processed (with a specified sampling) sequentially
+   *  and each time a user specified condition is verified, the chain is split into two chains.
+   *  The resulting set of chains is a partition of the initial chain
+   *  \param pred
+   *           The predicate on a point that expresses the splitting
+   *           condition
+   *  \param sampling
+   *           The resolution used to sample the chain for the predicate
+   *           evaluation. (The chain is not actually resampled, a virtual point
+   *           only progresses along the curve using this resolution)
+   */
+  static void sequentialSplit(UnaryPredicate0D& pred, 
+                              float sampling = 0.f);
+
+  /*! Splits the current set of chains in a recursive way.
+   *  We process the points of each chain (with a specified sampling) to find
+   *  the point minimizing a specified function. The chain is split in two at this
+   *  point and the two new chains are processed in the same way.
+   *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
+   *  on the chain that is about to be processed.
+   *  \param func
+   *           The Unary Function evaluated at each point of the chain.
+   *           The splitting point is the point minimizing this function
+   *  \param pred
+   *           The Unary Predicate ex pressing the recursivity stopping condition.
+   *           This predicate is evaluated for each curve before it actually gets
+   *           split. If pred(chain) is true, the curve won't be split anymore.
+   *  \param sampling
+   *           The resolution used to sample the chain for the predicates
+   *           evaluation. (The chain is not actually resampled, a virtual point
+   *           only progresses along the curve using this resolution)
+   */
+  static void recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate1D& pred, float sampling = 0);
+
+  /*! Splits the current set of chains in a recursive way.
+   *  We process the points of each chain (with a specified sampling) to find
+   *  the point minimizing a specified function. The chain is split in two at this
+   *  point and the two new chains are processed in the same way.
+   *  The user can specify a 0D predicate to make a first selection 
+   *  on the points that can potentially be split.
+   *  A point that doesn't verify the 0D predicate won't be candidate 
+   *  in realizing the min.
+   *  The recursivity level is controlled through a predicate 1D that expresses a stopping condition
+   *  on the chain that is about to be processed.
+   *  \param func
+   *           The Unary Function evaluated at each point of the chain.
+   *           The splitting point is the point minimizing this function
+   *  \param pred0d
+   *           The Unary Predicate 0D used to select the candidate points 
+   *           where the split can occur.
+   *           For example, it is very likely that would rather have  
+   *           your chain splitting around its middle point than around 
+   *           one of its extremities. A 0D predicate working on 
+   *           the curvilinear abscissa allows to add this kind of constraints.
+   *  \param pred
+   *           The Unary Predicate ex pressing the recursivity stopping condition.
+   *           This predicate is evaluated for each curve before it actually gets
+   *           split. If pred(chain) is true, the curve won't be split anymore.
+   *  \param sampling
+   *           The resolution used to sample the chain for the predicates
+   *           evaluation. (The chain is not actually resampled, a virtual point
+   *           only progresses along the curve using this resolution)
+   *           
+   */
+  static void recursiveSplit(UnaryFunction0D<double>& func, UnaryPredicate0D& pred0d, UnaryPredicate1D& pred, float sampling = 0);
+    
+  /*! Sorts the current set of chains (or viewedges) according to the
+   * comparison predicate given as argument.
+   *  \param pred
+   *           The binary predicate used for the comparison
+   */
+  static void sort(BinaryPredicate1D& pred);
+
+  /*! Creates and shades the strokes from the current set of chains.
+   *  A predicate can be specified to make a selection pass on the
+   *  chains.
+   *  \param pred
+   *           The predicate that a chain must verify in order to
+   *           be transform as a stroke
+   *  \param shaders
+   *           The list of shaders used to shade the strokes
+   */
+  static void create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders);
+
+  //
+  // Data access
+  //
+  ////////////////////////////////////////////////
+
+  static ViewEdge* getViewEdgeFromIndex(unsigned i) {
+    return dynamic_cast<ViewEdge*>(_current_view_edges_set[i]);
+  }
+  
+  static Chain* getChainFromIndex(unsigned i) {
+    return dynamic_cast<Chain*>(_current_chains_set[i]);
+  }
+    
+  static Stroke* getStrokeFromIndex(unsigned i) {
+    return _current_strokes_set[i];
+  }
+  
+  static unsigned getViewEdgesSize() {
+    return _current_view_edges_set.size();
+  }
+  
+  static unsigned getChainsSize() {
+    return _current_chains_set.size();
+  }
+
+  static unsigned getStrokesSize() {
+    return _current_strokes_set.size();
+  }
+  
+  //
+  // Not exported in Python
+  //
+  //////////////////////////////////////////////////
+
+  static StrokesContainer* getStrokesSet() {
+    return &_current_strokes_set;
+  }
+
+  static void reset();
+
+private:
+
+  Operators() {}
+
+  static I1DContainer		_current_view_edges_set;
+  static I1DContainer		_current_chains_set;
+  static I1DContainer*		_current_set;
+  static StrokesContainer	_current_strokes_set;
+};
+
+#endif // OPERATORS_H
diff --git a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.cpp b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.cpp
new file mode 100755
index 00000000000..dc9c94e0e11
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.cpp
@@ -0,0 +1,89 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "PSStrokeRenderer.h"
+# include "Canvas.h"
+
+PSStrokeRenderer::PSStrokeRenderer(const char* iFileName)
+:StrokeRenderer(){
+  if(!iFileName)
+    iFileName = "freestyle.ps";
+  // open the stream:
+  _ofstream.open(iFileName, ios::out);
+  if(!_ofstream.is_open()){
+    cerr << "couldn't open the output file " << iFileName << endl;
+  }
+  _ofstream << "%!PS-Adobe-2.0 EPSF-2.0" << endl;
+  _ofstream << "%%Creator: Freestyle (http://artis.imag.fr/Software/Freestyle)" << endl;
+  _ofstream << "%%BoundingBox: " << 0 << " "<< 0 << " " << Canvas::getInstance()->width() << " " << Canvas::getInstance()->height() << endl;
+  _ofstream << "%%EndComments" << endl;
+}
+
+PSStrokeRenderer::~PSStrokeRenderer(){
+  Close();
+}
+
+void PSStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const{
+  RenderStrokeRepBasic(iStrokeRep);
+}
+
+void PSStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) const{
+  vector<Strip*>& strips = iStrokeRep->getStrips();
+  Strip::vertex_container::iterator v[3];
+  StrokeVertexRep *svRep[3];
+  Vec3r color[3];
+  for(vector<Strip*>::iterator s=strips.begin(), send=strips.end();
+  s!=send;
+  ++s){
+    Strip::vertex_container& vertices = (*s)->vertices();
+    v[0] = vertices.begin();
+    v[1] = v[0];++(v[1]);
+    v[2] = v[1]; ++(v[2]);
+
+    while(v[2]!=vertices.end()){
+      svRep[0] = *(v[0]);
+      svRep[1] = *(v[1]);
+      svRep[2] = *(v[2]);
+      
+      color[0] = svRep[0]->color();
+      //color[1] = svRep[1]->color();
+      //color[2] = svRep[2]->color();
+      
+      _ofstream << "newpath" << endl;
+      _ofstream << (color[0])[0] << " " << (color[0])[1] << " " << (color[0])[2] << " setrgbcolor" <<endl;
+      _ofstream << svRep[0]->point2d()[0] << " " <<svRep[0]->point2d()[1] << " moveto" << endl;
+      _ofstream << svRep[1]->point2d()[0] << " " <<svRep[1]->point2d()[1] << " lineto" << endl;
+      _ofstream << svRep[2]->point2d()[0] << " " <<svRep[2]->point2d()[1] << " lineto" << endl;
+      _ofstream << "closepath" << endl;
+      _ofstream << "fill" << endl;
+
+      ++v[0];
+      ++v[1];
+      ++v[2];
+    }  
+  }
+}
+
+void PSStrokeRenderer::Close(){
+  if(_ofstream.is_open())
+    _ofstream.close();
+}
+
diff --git a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
new file mode 100755
index 00000000000..821c016ab91
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h
@@ -0,0 +1,63 @@
+//
+//  Filename         : PSStrokeRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the Postscript rendering of a stroke
+//  Date of creation : 10/26/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PSSTROKERENDERER_H
+# define PSSTROKERENDERER_H
+
+# include "../system/FreestyleConfig.h"
+# include "StrokeRenderer.h"
+# include <fstream>
+
+/**********************************/
+/*                                */
+/*                                */
+/*         PSStrokeRenderer       */
+/*                                */
+/*                                */
+/**********************************/
+
+class LIB_STROKE_EXPORT PSStrokeRenderer : public StrokeRenderer
+{
+public:
+  PSStrokeRenderer(const char * iFileName = 0);
+  virtual ~PSStrokeRenderer();
+
+  /*! Renders a stroke rep */
+  virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
+  virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;
+
+  /*! Closes the output PS file */
+  void Close();
+
+protected:
+  mutable ofstream _ofstream;
+};
+
+#endif // PSSTROKERENDERER_H
+
diff --git a/source/blender/freestyle/intern/stroke/Predicates0D.h b/source/blender/freestyle/intern/stroke/Predicates0D.h
new file mode 100755
index 00000000000..4c2dfacdf98
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Predicates0D.h
@@ -0,0 +1,160 @@
+//
+//  Filename         : Predicates0D.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class gathering stroke creation algorithms
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PREDICATES0D_H
+# define PREDICATES0D_H
+
+# include "../view_map/Functions0D.h"
+
+//
+// UnaryPredicate0D (base class for predicates in 0D)
+//
+///////////////////////////////////////////////////////////
+/*! Base class for Unary Predicates that work
+ *  on Interface0DIterator.
+ *  A UnaryPredicate0D is a functor that evaluates
+ *  a condition on a Interface0DIterator and returns
+ *  true or false depending on whether this condition is
+ *  satisfied or not.
+ *  The UnaryPredicate0D is used by calling its () operator.
+ *  Any inherited class must overload the () operator.
+ */
+class UnaryPredicate0D
+{
+public:
+  /*! Default constructor. */
+  UnaryPredicate0D() {}
+  /*! Destructor. */
+  virtual ~UnaryPredicate0D() {}
+  /*! Returns the string of the name
+   *  of the UnaryPredicate0D.
+   */
+  virtual string getName() const {
+    return "UnaryPredicate0D";
+  }
+  /*! The () operator. Must be overload
+   *  by inherited classes.
+   *  \param it
+   *    The Interface0DIterator pointing onto the
+   *    Interface0D at which we wish to evaluate
+   *    the predicate.
+   *  \return true if the condition is satisfied,
+   *    false otherwise.
+   */
+  virtual bool operator()(Interface0DIterator& it) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return false;
+  }
+};
+
+
+//
+// BinaryPredicate0D (base class for predicates in 0D)
+//
+///////////////////////////////////////////////////////////
+/*! Base class for Binary Predicates working on Interface0D.
+ *  A BinaryPredicate0D is typically an ordering relation
+ *  between two Interface0D.
+ *  It evaluates a relation between 2 Interface0D and
+ *  returns true or false.
+ *  It is used by calling the () operator.
+ */
+class BinaryPredicate0D
+{
+public:
+  /*! Default constructor. */
+  BinaryPredicate0D() {}
+  /*! Destructor. */
+  virtual ~BinaryPredicate0D() {}
+  /*! Returns the string of the name of the
+   * binary predicate.
+   */
+  virtual string getName() const {
+    return "BinaryPredicate0D";
+  }
+
+  /*! The () operator. Must be overload by inherited classes.
+   *  It evaluates a relation between 2 Interface0D.
+   *  \param inter1
+   *    The first Interface0D.
+   *  \param inter2
+   *    The second Interface0D.
+   *  \return true or false.
+   */
+  virtual bool operator()(Interface0D& inter1, Interface0D& inter2) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return false;
+  }
+};
+
+
+//
+// Predicates definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Predicates0D {
+
+  // TrueUP0D
+  /*! Returns true any time */
+  class TrueUP0D : public UnaryPredicate0D
+  {
+  public:
+    /*! Default constructor. */
+    TrueUP0D() {}
+    /*! Returns the string "TrueUP0D"*/
+    string getName() const {
+      return "TrueUP0D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface0DIterator&) {
+      return true;
+    }
+  };
+
+  // FalseUP0D
+  /*! Returns false any time */
+  class FalseUP0D : public UnaryPredicate0D
+  {
+  public:
+    /*! Default constructor. */
+    FalseUP0D() {}
+    /*! Returns the string "FalseUP0D"*/
+    string getName() const {
+      return "FalseUP0D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface0DIterator&) {
+      return false;
+    }
+  };
+
+} // end of namespace Predicates0D
+
+#endif // PREDICATES0D_H
diff --git a/source/blender/freestyle/intern/stroke/Predicates1D.h b/source/blender/freestyle/intern/stroke/Predicates1D.h
new file mode 100755
index 00000000000..cf9a3283ae4
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Predicates1D.h
@@ -0,0 +1,438 @@
+//
+//  Filename         : Predicates1D.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class gathering stroke creation algorithms
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PREDICATES1D_H
+# define PREDICATES1D_H
+
+# include <string>
+# include "../system/TimeStamp.h"
+# include "../view_map/Interface1D.h"
+# include "../view_map/Functions1D.h"
+# include "AdvancedFunctions1D.h"
+
+//
+// UnaryPredicate1D (base class for predicates in 1D)
+//
+///////////////////////////////////////////////////////////
+/*! Base class for Unary Predicates that work
+ *  on Interface1D.
+ *  A UnaryPredicate1D is a functor that evaluates
+ *  a condition on a Interface1D and returns
+ *  true or false depending on whether this condition is
+ *  satisfied or not.
+ *  The UnaryPredicate1D is used by calling its () operator.
+ *  Any inherited class must overload the () operator.
+ */
+class UnaryPredicate1D
+{
+public:
+  /*! Default constructor. */
+  UnaryPredicate1D() {}
+  /*! Destructor. */
+  virtual ~UnaryPredicate1D() {}
+  /*! Returns the string of the name
+   *  of the UnaryPredicate1D.
+   */
+  virtual string getName() const {
+    return "UnaryPredicate1D";
+  }
+  /*! The () operator. Must be overload
+   *  by inherited classes.
+   *  \param inter
+   *    The Interface1D on  which we wish to evaluate
+   *    the predicate.
+   *  \return true if the condition is satisfied,
+   *    false otherwise.
+   */
+  virtual bool operator()(Interface1D& inter) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return false;
+  }
+};
+
+
+//
+// BinaryPredicate1D (base class for predicates in 1D)
+//
+///////////////////////////////////////////////////////////
+/*! Base class for Binary Predicates working on Interface1D.
+ *  A BinaryPredicate1D is typically an ordering relation
+ *  between two Interface1D.
+ *  It evaluates a relation between 2 Interface1D and
+ *  returns true or false.
+ *  It is used by calling the () operator.
+ */
+class BinaryPredicate1D
+{
+public:
+  /*! Default constructor. */
+  BinaryPredicate1D() {}
+  /*! Destructor. */
+  virtual ~BinaryPredicate1D() {}
+  /*! Returns the string of the name of the
+   * binary predicate.
+   */
+  virtual string getName() const {
+    return "BinaryPredicate1D";
+  }
+  /*! The () operator. Must be overload by inherited classes.
+   *  It evaluates a relation between 2 Interface1D.
+   *  \param inter1
+   *    The first Interface1D.
+   *  \param inter2
+   *    The second Interface1D.
+   *  \return true or false.
+   */
+  virtual bool operator()(Interface1D& inter1, Interface1D& inter2) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return false;
+  }
+};
+
+
+//
+// Predicates definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Predicates1D {
+
+  // TrueUP1D
+  /*! Returns true */
+  class TrueUP1D : public UnaryPredicate1D
+  {
+  public:
+    /*! Constructor */
+    TrueUP1D() {}
+    /*! Returns the string "TrueUP1D"*/
+    string getName() const {
+      return "TrueUP1D";
+    }
+    /*! the () operator */
+    bool operator()(Interface1D&) {
+      return true;
+    }
+  };
+
+  // FalseUP1D
+  /*! Returns false */
+  class FalseUP1D : public UnaryPredicate1D
+  {
+  public:
+    /*! Constructor */
+    FalseUP1D() {}
+    /*! Returns the string "FalseUP1D"*/
+    string getName() const {
+      return "FalseUP1D";
+    }
+    /*! the () operator */
+    bool operator()(Interface1D&) {
+      return false;
+    }
+  };
+
+  // QuantitativeInvisibilityUP1D
+  /*! Returns true if the Quantitative Invisibility evaluated
+   *  at an Interface1D, using the QuantitativeInvisibilityF1D
+   *  functor, equals a certain user-defined value.
+   */
+  class QuantitativeInvisibilityUP1D : public UnaryPredicate1D
+  {
+  public:
+    /*! Builds the Predicate.
+     *  \param qi
+     *    The Quantitative Invisibility you want
+     *    the Interface1D to have
+     */
+    QuantitativeInvisibilityUP1D(unsigned qi = 0) : _qi(qi) {}
+    /*! Returns the string "QuantitativeInvisibilityUP1D"*/
+    string getName() const {
+      return "QuantitativeInvisibilityUP1D";
+    }
+    /*! the () operator */
+    bool operator()(Interface1D& inter) {
+      Functions1D::QuantitativeInvisibilityF1D func;
+      return (func(inter) == _qi);
+    }
+  private:
+    unsigned _qi;
+  };
+
+  // ContourUP1D
+  /*! Returns true if the Interface1D is a contour.
+   *  An Interface1D is a contour if it is borded
+   *  by a different shape on each of its sides.
+   */
+  class ContourUP1D : public UnaryPredicate1D
+  {
+  private:
+    Functions1D::CurveNatureF1D _getNature;
+  public:
+    /*! Returns the string "ContourUP1D"*/
+    string getName() const {
+      return "ContourUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      if((_getNature(inter) & Nature::SILHOUETTE) || (_getNature(inter) & Nature::BORDER)){
+        Interface0DIterator it=inter.verticesBegin();
+        for(; !it.isEnd(); ++it){
+          if(Functions0D::getOccludeeF0D(it) != Functions0D::getShapeF0D(it))
+            return true;
+        }
+      }
+      return false;
+    }
+  };
+
+  // ExternalContourUP1D
+  /*! Returns true if the Interface1D is an external contour.
+   *  An Interface1D is an external contour if it is borded
+   *  by no shape on one of its sides.
+   */
+  class ExternalContourUP1D : public UnaryPredicate1D
+  {
+  private:
+    Functions1D::CurveNatureF1D _getNature;
+  public:
+    /*! Returns the string "ExternalContourUP1D"*/
+    string getName() const {
+      return "ExternalContourUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      if((_getNature(inter) & Nature::SILHOUETTE) || (_getNature(inter) & Nature::BORDER)){
+        set<ViewShape*> occluded;
+        Functions1D::getOccludeeF1D(inter, occluded);
+        for(set<ViewShape*>::iterator os=occluded.begin(), osend=occluded.end();
+            os!=osend;
+            ++os){
+          if((*os) == 0)
+            return true;
+        }
+      }
+      return false;
+    }
+  };
+
+  // EqualToTimeStampUP1D
+  /*! Returns true if the Interface1D's time stamp
+   *  is equal to a certain user-defined value.
+   */
+  class EqualToTimeStampUP1D : public UnaryPredicate1D
+  {
+  protected:
+    unsigned _timeStamp; 
+  public:
+    EqualToTimeStampUP1D(unsigned ts) : UnaryPredicate1D(){
+      _timeStamp = ts;
+    }
+    /*! Returns the string "EqualToTimeStampUP1D"*/
+    string getName() const {
+      return "EqualToTimeStampUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      return (inter.getTimeStamp() == _timeStamp);
+    }
+  };
+
+  // EqualToChainingTimeStampUP1D
+  /*! Returns true if the Interface1D's time stamp
+   *  is equal to a certain user-defined value.
+   */
+  class EqualToChainingTimeStampUP1D : public UnaryPredicate1D
+  {
+  protected:
+    unsigned _timeStamp; 
+  public:
+    EqualToChainingTimeStampUP1D(unsigned ts) : UnaryPredicate1D(){
+      _timeStamp = ts;
+    }
+    /*! Returns the string "EqualToChainingTimeStampUP1D"*/
+    string getName() const {
+      return "EqualToChainingTimeStampUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      ViewEdge* edge = dynamic_cast<ViewEdge*>(&inter);
+      if (!edge)
+	return false;
+      return (edge->getChainingTimeStamp() >= _timeStamp);
+    }
+  };
+
+  // ShapeUP1D
+  /*! Returns true if the shape to which the Interface1D
+   *  belongs to has the same Id as the one specified by the
+   *  user.
+   */
+  class ShapeUP1D: public UnaryPredicate1D
+  {
+  private:
+    Id _id;
+  public:
+    /*! Builds the Predicate.
+     *  \param idFirst
+     *    The first Id component.
+     *  \param idSecond
+     *    The second Id component.
+     */
+    ShapeUP1D(unsigned idFirst, unsigned idSecond=0) 
+      : UnaryPredicate1D(){
+      _id = Id(idFirst, idSecond);
+    }
+    /*! Returns the string "ShapeUP1D"*/
+    string getName() const {
+      return "ShapeUP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& inter) {
+      set<ViewShape*> shapes;
+      Functions1D::getShapeF1D(inter, shapes);
+      for(set<ViewShape*>::iterator s=shapes.begin(), send=shapes.end();
+      s!=send;
+      ++s){
+        if((*s)->getId() == _id)
+          return true;
+      }
+      return false;
+    }
+  };
+  
+  //
+  //   Binary Predicates definitions
+  //
+  ///////////////////////////////////////////////////////////
+
+  // TrueBP1D
+  /*! Returns true. */
+  class TrueBP1D : public BinaryPredicate1D
+  {
+  public:
+    /*! Returns the string "TrueBP1D"*/
+    string getName() const {
+      return "TrueBP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& i1, Interface1D& i2) {
+      return true;
+    }
+  };
+
+  // FalseBP1D
+    /*! Returns false. */
+  class FalseBP1D : public BinaryPredicate1D
+  {
+  public:
+    /*! Returns the string "FalseBP1D"*/
+    string getName() const {
+      return "FalseBP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& i1, Interface1D& i2) {
+      return false;
+    }
+  };
+  
+  // Length2DBP1D
+  /*! Returns true if the 2D length of the Interface1D i1
+   *  is less than the 2D length of the Interface1D i2.
+   */
+  class Length2DBP1D : public BinaryPredicate1D
+  {
+  public:
+    /*! Returns the string "Length2DBP1D"*/
+    string getName() const {
+      return "Length2DBP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& i1, Interface1D& i2) {
+      return (i1.getLength2D() > i2.getLength2D());
+    }
+  };
+
+  // SameShapeIdBP1D
+  /*! Returns true if the Interface1D i1 and i2 belong
+   *  to the same shape.
+   */
+  class SameShapeIdBP1D : public BinaryPredicate1D
+  {
+  public:
+    /*! Returns the string "SameShapeIdBP1D"*/
+    string getName() const {
+      return "SameShapeIdBP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& i1, Interface1D& i2) {
+      set<ViewShape*> shapes1;
+      Functions1D::getShapeF1D(i1, shapes1);
+      set<ViewShape*> shapes2;
+      Functions1D::getShapeF1D(i2, shapes2);
+      // FIXME:// n2 algo, can do better...
+      for(set<ViewShape*>::iterator s=shapes1.begin(), send=shapes1.end();
+          s!=send;
+          ++s){
+        Id current = (*s)->getId();
+        for(set<ViewShape*>::iterator s2=shapes2.begin(), s2end=shapes2.end();
+          s2!=s2end;
+          ++s2){
+          if((*s2)->getId() == current)
+            return true;
+        }
+      }
+      return false;
+    }
+  };
+
+  // ViewMapGradientNormBP1D
+  /*! Returns true if the evaluation of the 
+   *  Gradient norm Function is higher for Interface1D i1 
+   *  than for i2.
+   */
+  class ViewMapGradientNormBP1D : public BinaryPredicate1D
+  {
+  private:
+    Functions1D::GetViewMapGradientNormF1D _func;
+  public:
+    ViewMapGradientNormBP1D(int level, IntegrationType iType=MEAN, float sampling=2.0) 
+      : BinaryPredicate1D(), _func(level, iType, sampling) {
+    }
+    /*! Returns the string "ViewMapGradientNormBP1D"*/
+    string getName() const {
+      return "ViewMapGradientNormBP1D";
+    }
+    /*! The () operator. */
+    bool operator()(Interface1D& i1, Interface1D& i2) {
+      return (_func(i1) > _func(i2));
+    }
+  };
+} // end of namespace Predicates1D
+
+#endif // PREDICATES1D_H
diff --git a/source/blender/freestyle/intern/stroke/QInformationMap.h b/source/blender/freestyle/intern/stroke/QInformationMap.h
new file mode 100755
index 00000000000..ef068f15061
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/QInformationMap.h
@@ -0,0 +1,58 @@
+//
+//  Filename         : QInformationMap.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class defining an information map using a QImage
+//  Date of creation : 04/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  QINFORMATIONMAP_H
+# define QINFORMATIONMAP_H
+
+# include <qimage.h>
+# include "InformationMap.h"
+
+class QInformationMap : public InformationMap
+{
+private:
+  QImage _map; // the image or a piece of image
+
+public:
+  QInformationMap();
+  QInformationMap(const QImage&);
+  QInformationMap(const QInformationMap&);
+  QInformationMap& operator=(const QInformationMap&);
+
+  //float getSmoothedPixel(int x, int y, float sigma = 0.2f)
+  virtual float getMean(int x, int y) ;
+  virtual void retrieveMeanAndVariance(int x, int y, float &oMean, float &oVariance) ;
+
+  inline const QImage& map() const {return _map;}
+  inline void setMap(const QImage& iMap, float iw, float ih) {_map = iMap.copy();_w=iw;_h=ih;}
+
+protected:
+  virtual float computeGaussian(int x, int y);
+};
+
+#endif // QINFORMATIONMAP_H
diff --git a/source/blender/freestyle/intern/stroke/Stroke.cpp b/source/blender/freestyle/intern/stroke/Stroke.cpp
new file mode 100755
index 00000000000..c6b52358264
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Stroke.cpp
@@ -0,0 +1,949 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Stroke.h"
+#include "StrokeRenderer.h"
+#include "StrokeIterators.h"
+#include "StrokeAdvancedIterators.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*         StrokeAttribute        */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+StrokeAttribute::StrokeAttribute()
+{
+  int i;
+  _alpha = 1.f;
+  _thickness[0] = 1.f;
+  _thickness[1] = 1.f;
+  for(i=0; i<3; ++i)
+    _color[i] = 0.2f;
+  _color[0]=0.8;
+  _userAttributesReal = 0;
+  _userAttributesVec2f = 0;
+  _userAttributesVec3f = 0;
+  _visible = true;
+}
+StrokeAttribute::StrokeAttribute(const StrokeAttribute& iBrother)
+{
+  _alpha = iBrother._alpha;
+  _thickness[0] = iBrother._thickness[0];
+  _thickness[1] = iBrother._thickness[1];
+  for(int i=0; i<3; ++i)
+    _color[i] = iBrother._color[i];
+  _visible = iBrother._visible;
+  if(iBrother._userAttributesReal)
+    _userAttributesReal = new realMap(*iBrother._userAttributesReal);
+  else
+    _userAttributesReal = 0;
+  if(iBrother._userAttributesVec2f)
+    _userAttributesVec2f = new Vec2fMap(*iBrother._userAttributesVec2f);
+  else
+    _userAttributesVec2f = 0;
+  if(iBrother._userAttributesVec3f)
+    _userAttributesVec3f = new Vec3fMap(*iBrother._userAttributesVec3f);
+  else
+    _userAttributesVec3f = 0;
+}
+StrokeAttribute::StrokeAttribute( float iRColor, float iGColor, float iBColor,
+                                  float iAlpha,
+                                  float iRThickness, float iLThickness)
+{
+  _color[0] = iRColor;
+  _color[1] = iGColor;
+  _color[2] = iBColor;
+
+  _alpha = iAlpha;
+
+  _thickness[0] = iRThickness;
+  _thickness[1] = iLThickness;
+  
+  _visible = true;
+
+  _userAttributesReal = 0;
+  _userAttributesVec2f = 0;
+  _userAttributesVec3f = 0;
+}
+StrokeAttribute::StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t)
+
+{
+
+  _alpha = (1-t)*a1._alpha + t*a2._alpha;
+  _thickness[0] = (1-t)*a1._thickness[0] + t*a2._thickness[0];
+  _thickness[1] = (1-t)*a1._thickness[1] + t*a2._thickness[1];
+  for(int i=0; i<3; ++i)
+    _color[i] = (1-t)*a1._color[i] + t*a2._color[i];
+
+  _visible = true;
+  
+  // FIXME: a verifier (et a ameliorer)
+  if((a1._userAttributesReal) && (a2._userAttributesReal)){
+    if(a1._userAttributesReal->size() == a2._userAttributesReal->size()){
+      _userAttributesReal = new realMap;
+      realMap::iterator it1=a1._userAttributesReal->begin(), it1end=a1._userAttributesReal->end();
+      realMap::iterator it2=a2._userAttributesReal->begin(), it2end=a2._userAttributesReal->end();
+      for(; (it1!=it1end); ++it1){
+        (*_userAttributesReal)[(*it1).first] = ((1-t)*(*it1).second+t*(*it2).second);
+      }
+    }
+  }else{
+    _userAttributesReal = 0;
+  }
+  if((a1._userAttributesVec2f) && (a2._userAttributesVec2f)){
+    if(a1._userAttributesVec2f->size() == a2._userAttributesVec2f->size()){
+      _userAttributesVec2f = new Vec2fMap;
+      Vec2fMap::iterator it1=a1._userAttributesVec2f->begin(), it1end=a1._userAttributesVec2f->end();
+      Vec2fMap::iterator it2=a2._userAttributesVec2f->begin(), it2end=a2._userAttributesVec2f->end();
+      for(; (it1!=it1end); ++it1){
+        (*_userAttributesVec2f)[(*it1).first] = ((1-t)*(*it1).second+t*(*it2).second);
+      }
+    }
+  }else{
+    _userAttributesVec2f = 0;
+  }
+  if((a1._userAttributesVec3f) && (a2._userAttributesVec3f)){
+    if(a1._userAttributesVec3f->size() == a2._userAttributesVec3f->size()){
+      _userAttributesVec3f = new Vec3fMap;
+      Vec3fMap::iterator it1=a1._userAttributesVec3f->begin(), it1end=a1._userAttributesVec3f->end();
+      Vec3fMap::iterator it2=a2._userAttributesVec3f->begin(), it2end=a2._userAttributesVec3f->end();
+      for(; (it1!=it1end); ++it1){
+        (*_userAttributesVec3f)[(*it1).first] = ((1-t)*(*it1).second+t*(*it2).second);
+      }
+    }
+  }else{
+    _userAttributesVec3f = 0;
+  }
+
+}
+StrokeAttribute::~StrokeAttribute()
+{
+  if(_userAttributesReal){
+    _userAttributesReal->clear();
+    delete _userAttributesReal;
+  }
+  if(_userAttributesVec2f){
+    _userAttributesVec2f->clear();
+    delete _userAttributesVec2f;
+  }
+  if(_userAttributesVec3f){
+    _userAttributesVec3f->clear();
+    delete _userAttributesVec3f;
+  }
+}
+
+StrokeAttribute& StrokeAttribute::operator=(const StrokeAttribute& iBrother)
+{ 
+  int i;
+  _alpha = iBrother._alpha;
+  _thickness[0] = iBrother._thickness[0];
+  _thickness[1] = iBrother._thickness[1];
+  for(i=0; i<3; ++i)
+    _color[i] = iBrother._color[i];
+  _visible = iBrother._visible;
+  if(iBrother._userAttributesReal){
+    if(!_userAttributesReal)
+      _userAttributesReal = new realMap;
+    _userAttributesReal = new realMap(*(iBrother._userAttributesReal));
+  }else{
+    _userAttributesReal = 0;
+  }
+  if(iBrother._userAttributesVec2f){
+    if(!_userAttributesVec2f)
+      _userAttributesVec2f = new Vec2fMap;
+    _userAttributesVec2f = new Vec2fMap(*(iBrother._userAttributesVec2f));
+  }else{
+    _userAttributesVec2f = 0;
+  }
+  if(iBrother._userAttributesVec3f){
+    if(!_userAttributesVec3f)
+      _userAttributesVec3f = new Vec3fMap;
+    _userAttributesVec3f = new Vec3fMap(*(iBrother._userAttributesVec3f));
+  }else{
+    _userAttributesVec3f = 0;
+  } 
+  return *this;
+}
+
+float StrokeAttribute::getAttributeReal(const char *iName) const{
+  if(!_userAttributesReal){
+    cout << "StrokeAttribute warning: no real attribute was defined"<< endl;
+    return 0;
+  }
+  realMap::iterator a = _userAttributesReal->find(iName);
+  if(a ==_userAttributesReal->end()){
+    cout << "StrokeAttribute warning: no real attribute was added with the name " << iName << endl;
+    return 0;
+  }
+  return (*a).second;
+}
+Vec2f StrokeAttribute::getAttributeVec2f(const char *iName) const{
+  if(!_userAttributesVec2f){
+    cout << "StrokeAttribute warning: no Vec2f attribute was defined "<< endl;
+    return 0;
+  }
+  Vec2fMap::iterator a = _userAttributesVec2f->find(iName);
+  if(a ==_userAttributesVec2f->end()){
+    cout << "StrokeAttribute warning: no Vec2f attribute was added with the name " << iName << endl;
+    return 0;
+  }
+  return (*a).second;
+}
+Vec3f StrokeAttribute::getAttributeVec3f(const char *iName) const{
+  if(!_userAttributesVec3f){
+    cout << "StrokeAttribute warning: no Vec3f attribute was defined"<< endl;
+    return 0;
+  }
+  Vec3fMap::iterator a = _userAttributesVec3f->find(iName);
+  if(a ==_userAttributesVec3f->end()){
+    cout << "StrokeAttribute warning: no Vec3f attribute was added with the name " << iName << endl;
+    return 0;
+  }
+  return (*a).second;
+}
+bool StrokeAttribute::isAttributeAvailableReal(const char *iName) const{
+  if(!_userAttributesReal){
+    return false;
+  }
+  realMap::iterator a = _userAttributesReal->find(iName);
+  if(a ==_userAttributesReal->end()){
+    return false;
+  }
+  return true;
+}
+bool StrokeAttribute::isAttributeAvailableVec2f(const char *iName) const{
+  if(!_userAttributesVec2f){
+    return false;
+  }
+  Vec2fMap::iterator a = _userAttributesVec2f->find(iName);
+  if(a ==_userAttributesVec2f->end()){
+    return false;
+  }
+  return true;
+}
+bool StrokeAttribute::isAttributeAvailableVec3f(const char *iName) const{
+  if(!_userAttributesVec3f){
+    return false;
+  }
+  Vec3fMap::iterator a = _userAttributesVec3f->find(iName);
+  if(a ==_userAttributesVec3f->end()){
+    return false;
+  }
+  return true;
+}
+void StrokeAttribute::setAttributeReal(const char *iName, float att){
+  if(!_userAttributesReal)
+    _userAttributesReal = new realMap;
+  (*_userAttributesReal)[iName] = att;
+}
+void StrokeAttribute::setAttributeVec2f(const char *iName, const Vec2f& att){
+  if(!_userAttributesVec2f)
+    _userAttributesVec2f = new Vec2fMap;
+  (*_userAttributesVec2f)[iName] = att;
+}
+void StrokeAttribute::setAttributeVec3f(const char *iName, const Vec3f& att){
+  if(!_userAttributesVec3f)
+    _userAttributesVec3f = new Vec3fMap;
+  (*_userAttributesVec3f)[iName] = att;
+}
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*           StrokeVertex         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+StrokeVertex::StrokeVertex()
+
+:CurvePoint()
+{
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+}
+
+
+
+StrokeVertex::StrokeVertex(const StrokeVertex& iBrother)
+
+:CurvePoint(iBrother)
+{
+  _Attribute = iBrother._Attribute;
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+}
+StrokeVertex::StrokeVertex(SVertex *iSVertex)
+
+:CurvePoint(iSVertex,0,0.f)
+
+{
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+
+}
+
+
+
+StrokeVertex::StrokeVertex(CurvePoint *iPoint)
+
+:CurvePoint(*iPoint)
+
+{
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+
+}
+
+
+
+StrokeVertex::StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3)
+
+:CurvePoint(iA,iB,t3)
+
+{
+
+  // interpolate attributes:
+
+  _Attribute = StrokeAttribute(iA->attribute(), iB->attribute(), t3);
+  _CurvilignAbscissa = (1-t3)*iA->curvilinearAbscissa()+t3*iB->curvilinearAbscissa();
+  _StrokeLength = iA->strokeLength();
+
+}
+
+  
+
+StrokeVertex::StrokeVertex(SVertex *iSVertex, const StrokeAttribute& iAttribute)
+
+:CurvePoint(iSVertex,0,0.f)
+
+{
+
+  _Attribute = iAttribute;
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+
+}
+StrokeVertex::~StrokeVertex()
+{
+}
+
+StrokeVertex& StrokeVertex::operator=(const StrokeVertex& iBrother)
+{ 
+  ((CurvePoint*)this)->operator=(iBrother);
+  _Attribute = iBrother._Attribute;
+
+  _CurvilignAbscissa = 0.f;
+
+  _StrokeLength = 0.f;
+  return *this;
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             Stroke             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+Stroke::Stroke()
+{
+  _Length = 0;
+  _id = 0;
+  _sampling = FLT_MAX;
+  //_mediumType = DEFAULT_STROKE;
+  _mediumType = OPAQUE_MEDIUM;
+  _textureId = 0;
+  _tips = false;
+  _rep = 0;
+}
+
+Stroke::Stroke(const Stroke& iBrother)
+{
+  for(vertex_container::const_iterator v=iBrother._Vertices.begin(), vend=iBrother._Vertices.end();
+      v!=vend;
+      v++)
+    {
+      _Vertices.push_back(*v);  
+    }
+  _Length = 0;
+  _id = iBrother._id;
+  _ViewEdges = iBrother._ViewEdges;
+  _sampling = iBrother._sampling;
+  _mediumType = iBrother._mediumType;
+  _textureId = iBrother._textureId;
+  _tips = iBrother._tips;
+  _rep = new StrokeRep(*(iBrother._rep));
+}
+
+Stroke::~Stroke()
+{
+  if(!_Vertices.empty())
+  {
+    for(vertex_container::iterator v=_Vertices.begin(), vend=_Vertices.end();
+    v!=vend;
+    v++)
+    {
+      delete (*v);
+    }
+    _Vertices.clear();
+  }
+
+  _ViewEdges.clear();
+  if(_rep != 0)
+  {
+    delete _rep;
+    _rep = 0;
+  }
+}
+
+Stroke& Stroke::operator=(const Stroke& iBrother)
+{ 
+  if(!_Vertices.empty())
+    _Vertices.clear();
+
+  for(vertex_container::const_iterator v=iBrother._Vertices.begin(), vend=iBrother._Vertices.end();
+  v!=vend;
+  v++)
+  {
+    _Vertices.push_back(*v);  
+  }
+  _Length = iBrother._Length;
+  _id = iBrother._id;
+  _ViewEdges = iBrother._ViewEdges;
+  _sampling = iBrother._sampling;
+  if(_rep) delete _rep;
+  if(iBrother._rep)
+    _rep = new StrokeRep(*(iBrother._rep));
+  return *this;
+}
+
+
+void Stroke::setLength(float iLength)
+{
+  _Length = iLength;
+  for(vertex_container::iterator v=_Vertices.begin(), vend=_Vertices.end();
+  v!=vend;
+  ++v)
+  {
+    (*v)->setStrokeLength(iLength);
+  }
+}
+
+float Stroke::ComputeSampling(int iNVertices)
+{
+  if(iNVertices <= (int)_Vertices.size()) //soc
+    return _sampling;
+
+  float sampling = _Length/(float)(iNVertices-_Vertices.size()+1);
+  return sampling;
+}
+
+class StrokeSegment
+{
+public:
+  StrokeInternal::StrokeVertexIterator _begin;
+  StrokeInternal::StrokeVertexIterator _end;
+  float _length;
+  int _n;
+  float _sampling;
+  bool _resampled;
+  
+  StrokeSegment(StrokeInternal::StrokeVertexIterator ibegin,
+                StrokeInternal::StrokeVertexIterator iend,
+                float ilength,
+                int in,
+                float isampling)
+                {
+                  _begin=ibegin;
+                  _end=iend;
+                  _length=ilength;
+                  _n=in;
+                  _sampling = isampling;
+                  _resampled = false;
+                }
+};
+
+void Stroke::Resample(int iNPoints)
+{
+  int vertsize = strokeVerticesSize();
+  if(iNPoints <= vertsize)
+    return;
+
+  StrokeInternal::StrokeVertexIterator it = strokeVerticesBegin();
+  StrokeInternal::StrokeVertexIterator next = it;++next;
+  StrokeInternal::StrokeVertexIterator itend = strokeVerticesEnd();
+
+  vertex_container newVertices;
+  real t=0.f;
+  StrokeVertex * newVertex = 0;
+  vector<StrokeSegment> strokeSegments;
+  int N=0;
+  float meanlength = 0;
+  int nsegments = 0;
+  while(((it!=itend)&&(next!=itend)))
+  { 
+    Vec3r a((it)->point2d());
+    Vec3r b((next)->point2d());
+    Vec3r vec_tmp(b - a);
+    real norm_var = vec_tmp.norm();
+    int numberOfPointsToAdd = (int)floor((iNPoints-strokeVerticesSize())*norm_var/_Length);
+    float csampling = norm_var/(float)(numberOfPointsToAdd+1);
+    strokeSegments.push_back(StrokeSegment(it,next,norm_var,numberOfPointsToAdd, csampling));
+    N+=numberOfPointsToAdd;
+    meanlength += norm_var;
+    ++nsegments;
+    ++it; ++next;
+  }
+  meanlength /= (float)nsegments;
+
+  // if we don't have enough points let's resample 
+  // finer some segments
+  int NPointsToAdd = iNPoints-vertsize;
+  bool checkEveryone = false;
+  while(N < NPointsToAdd)
+  {
+    for(vector<StrokeSegment>::iterator s=strokeSegments.begin(), send=strokeSegments.end();
+    s!=send;
+    ++s)
+    {
+      if(s->_sampling == 0.f)
+        continue;
+
+      if(s->_resampled == false)
+      {
+        if((!checkEveryone) && (s->_length < meanlength))
+          continue;
+        //resample
+        s->_n = s->_n+1;
+        s->_sampling = s->_length/(float)(s->_n+1);
+        s->_resampled = true;
+        N++;
+        if(N == NPointsToAdd)
+          break;
+      }
+    }
+    checkEveryone = true;
+  }
+  //actually resample:
+  for(vector<StrokeSegment>::iterator s=strokeSegments.begin(), send=strokeSegments.end();
+  s!=send;
+  ++s)
+  { 
+    newVertices.push_back(&(*(s->_begin)));
+    if(s->_sampling < _sampling)
+      _sampling = s->_sampling;
+    
+    t = s->_sampling/s->_length;
+    for(int i=0; i<s->_n; ++i)
+    {
+      newVertex = new StrokeVertex(&(*(s->_begin)),&(*(s->_end)),t);
+      newVertices.push_back(newVertex);
+      t += s->_sampling/s->_length;
+    }
+    it=s->_begin;
+    next=s->_end;
+  }
+
+  // add last:
+  ++it;++next;
+  if((it != itend) && (next == itend))// && (t == 0.f))
+    newVertices.push_back(&(*it));
+
+  int newsize = newVertices.size();
+  if(newsize != iNPoints)
+    cerr << "Warning: incorrect points number" << endl;
+
+  _Vertices.clear();
+  _Vertices = newVertices;
+  newVertices.clear();
+  
+  if(_rep)
+  {
+    delete _rep;
+    _rep = new StrokeRep(this);
+  }
+}
+
+
+void Stroke::Resample(float iSampling)
+{
+  //  cerr<<"old size :"<<strokeVerticesSize()<<endl;
+  if(iSampling == 0)
+
+    return;
+  if(iSampling >= _sampling)
+    return ;
+
+  _sampling = iSampling;   
+  // Resample...
+  //real curvilinearLength = 0.f;
+  vertex_container newVertices;
+  real t=0.f;
+  StrokeVertex * newVertex = 0;
+  StrokeInternal::StrokeVertexIterator it = strokeVerticesBegin();
+  StrokeInternal::StrokeVertexIterator next = it;++next;
+  StrokeInternal::StrokeVertexIterator itend = strokeVerticesEnd();
+  while(((it!=itend)&&(next!=itend)))
+  { 
+    newVertices.push_back(&(*it));
+    Vec3r a((it)->point2d());
+    Vec3r b((next)->point2d());
+    Vec3r vec_tmp(b - a);
+    real norm_var = vec_tmp.norm();
+    if(norm_var <= _sampling)
+    {
+      //curvilinearLength += norm_var;
+      ++it; ++next;
+      continue;
+    }
+
+  //curvilinearLength += _sampling;
+    t = _sampling/norm_var;
+    float limit = 0.99f;
+    while(t<limit)
+    {
+      newVertex = new StrokeVertex(&(*it),&(*next),t);
+      //newVertex->setCurvilinearAbscissa(curvilinearLength);
+      newVertices.push_back(newVertex);
+      t = t + _sampling/norm_var;
+    }
+    ++it; ++next;
+  }
+  // add last:
+  if((it != itend) && (next == itend))// && (t == 0.f))
+    newVertices.push_back(&(*it));
+
+  _Vertices.clear();
+  _Vertices = newVertices;
+  newVertices.clear();
+  
+  if(_rep)
+  {
+    delete _rep;
+    _rep = new StrokeRep(this);
+  }
+}
+
+void Stroke::RemoveVertex(StrokeVertex *iVertex)
+{
+  vertex_container::iterator it=_Vertices.begin(), itend=_Vertices.end();
+  for(;
+  it!=itend;
+  ++it)
+  {
+    if((*it) == iVertex)
+    {
+      delete iVertex;
+      it = _Vertices.erase(it); // it is now the element just after the erased element
+      break;
+    }
+  }
+  // recompute various values (length, curvilign abscissa)
+  float curvabsc = 0.f;
+  it=_Vertices.begin();
+  itend=_Vertices.end();
+  vertex_container::iterator previous=it;
+  for(;
+  (it!=itend);
+  ++it)
+  {
+    if(it != previous)
+      curvabsc += ((*it)->point2d()-(*previous)->point2d()).norm();
+    (*it)->setCurvilinearAbscissa(curvabsc);
+    previous = it;
+  }
+  _Length = curvabsc;
+  it=_Vertices.begin();
+  for(;
+  (it!=itend);
+  ++it)
+  {
+    (*it)->setStrokeLength(_Length);
+  }
+}
+
+void Stroke::InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next)
+{
+  vertex_container::iterator it=_Vertices.begin(), itend=_Vertices.end();
+
+  vertex_container::iterator itnext = next.getIt();
+  _Vertices.insert(itnext, iVertex);
+  // recompute various values (length, curvilign abscissa)
+  float curvabsc = 0.f;
+  it=_Vertices.begin();
+  itend=_Vertices.end();
+  vertex_container::iterator previous=it;
+  for(;
+  (it!=itend);
+  ++it)
+  {
+    curvabsc += ((*it)->point2d()-(*previous)->point2d()).norm();
+    (*it)->setCurvilinearAbscissa(curvabsc);
+    previous = it;
+  }
+  _Length = curvabsc;
+  for(;
+  (it!=itend);
+  ++it)
+  {
+    (*it)->setStrokeLength(_Length);
+  }
+}
+
+//! embedding vertex iterator
+Stroke::const_vertex_iterator Stroke::vertices_begin() const { return const_vertex_iterator(_Vertices.begin(),_Vertices.begin(), _Vertices.end()); }
+Stroke::const_vertex_iterator Stroke::vertices_end() const { return const_vertex_iterator(_Vertices.end(),_Vertices.begin(), _Vertices.end()); }
+Stroke::vertex_iterator Stroke::vertices_end() { return vertex_iterator(_Vertices.end(),_Vertices.begin(), _Vertices.end()); }
+
+StrokeInternal::StrokeVertexIterator Stroke::strokeVerticesBegin(float t) {
+  if((t!=0) && (t < _sampling))
+    Resample(t);
+  return StrokeInternal::StrokeVertexIterator(this->_Vertices.begin(), this->_Vertices.begin(), this->_Vertices.end());
+}
+
+StrokeInternal::StrokeVertexIterator Stroke::strokeVerticesEnd() {
+  return StrokeInternal::StrokeVertexIterator(this->_Vertices.end(), this->_Vertices.begin(), this->_Vertices.end());
+}
+
+Interface0DIterator Stroke::verticesBegin() {
+  Interface0DIterator ret(new StrokeInternal::StrokeVertexIterator(this->_Vertices.begin(),
+								   this->_Vertices.begin(),
+								   this->_Vertices.end()));
+  return ret;
+}
+
+Interface0DIterator Stroke::verticesEnd() {
+  Interface0DIterator ret(new StrokeInternal::StrokeVertexIterator(this->_Vertices.end(),
+								   this->_Vertices.begin(),
+								   this->_Vertices.end()));
+  return ret;
+}
+
+Interface0DIterator Stroke::pointsBegin(float t) {
+  return verticesBegin(); // FIXME
+}
+
+Interface0DIterator Stroke::pointsEnd(float t) {
+  return verticesEnd();
+}
+
+void Stroke::Render(const StrokeRenderer *iRenderer)
+{
+  if(!_rep)
+    _rep = new StrokeRep(this);
+  iRenderer->RenderStrokeRep(_rep);
+}
+
+void Stroke::RenderBasic(const StrokeRenderer *iRenderer)
+{
+  if(!_rep)
+    _rep = new StrokeRep(this);
+  iRenderer->RenderStrokeRepBasic(_rep);
+}
+
+Stroke::vertex_iterator Stroke::vertices_begin(float sampling) 
+{
+  // Resample if necessary
+  if((sampling != 0) && (sampling < _sampling))
+    Resample(sampling);
+  return vertex_iterator(_Vertices.begin(),_Vertices.begin(),_Vertices.end());
+  //return _Vertices.begin(); 
+}
+//
+//Stroke::vertex_iterator Stroke::vertices_last() 
+//{
+//  vertex_iterator res = vertices_begin();
+//  vertex_iterator next = res;++next;
+//  while(!next.end())
+//  {
+//    ++next;
+//    ++res;
+//  }
+//  return res;
+//}
+//
+//Stroke::const_vertex_iterator Stroke::vertices_last() const
+//{
+//  const_vertex_iterator res = vertices_begin();
+//  const_vertex_iterator next = res;++next;
+//  while(!next.end())
+//  {
+//    ++next;
+//    ++res;
+//  }
+//  return res;
+//}
+
+//Stroke::vertex_container::reverse_iterator Stroke::vertices_last(float sampling) 
+//{
+//  // Resample if necessary
+//  if(sampling < _sampling)
+//    Resample(sampling);
+//  return _Vertices.rbegin();
+//}
+
+
+//inline Vec3r shaded_color(int iCombination = 0) const ;
+//inline Vec<3,real> Stroke::orientation2d(const_vertex_iterator it) const 
+//{
+//  return iterator_edge_orientation2d_function<Stroke, const_vertex_iterator>(this, it);
+//}
+// Vec3r  Stroke::orientation2d(int iCombination) const 
+// {
+//   return edge_orientation2d_function<Stroke>(*this, iCombination);
+// }
+//inline Vec3r Stroke::orientation3d(const_vertex_iterator it) const 
+//{
+//  return iterator_edge_orientation3d_function<Stroke, const_vertex_iterator>(*this, it);
+//}
+// Vec3r  Stroke::orientation3d(int iCombination) const 
+// {
+//   return edge_orientation3d_function<Stroke>(*this, iCombination);
+// }
+
+//Material Stroke::material() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=strokeVerticesEnd();
+//  Material mat = (*v)->material();
+//  for(;v!=vend;++v)
+//  {
+//    if(mat != (*v)->material())
+//      Exception::raiseException();
+//  }
+//  return mat;
+//}
+
+//int Stroke::qi() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  int qi_= (*v)->qi();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->qi() != qi_)
+//      Exception::raiseException();
+//  }
+//  return qi_;
+//}
+//inline occluder_container::const_iterator occluders_begin() const {return _FEdgeA->occluders().begin();}
+//inline occluder_container::const_iterator occluders_end() const {return _FEdgeA->occluders().end();}
+
+//int Stroke::occluders_size() const 
+//{
+//  return qi();
+//}
+//
+//bool Stroke::occluders_empty() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  bool empty = (*v)->occluders_empty();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occluders_empty() != empty)
+//      Exception::raiseException();
+//  }
+//  return empty;
+//}
+////inline const polygon3d& occludee() const {return *(_FEdgeA->aFace());}
+//const SShape * Stroke::occluded_shape() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  const SShape *sshape = (*v)->occluded_shape();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occluded_shape() != sshape)
+//      Exception::raiseException();
+//  }
+//  return sshape;
+//}
+//
+//const bool Stroke::occludee_empty() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  bool empty = (*v)->occludee_empty();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->occludee_empty() != empty)
+//      Exception::raiseException();
+//  }
+//  return empty;
+//}
+
+//const SShape * Stroke::shape() const 
+//{
+//  const_vertex_iterator v=vertices_begin(), vend=vertices_end();
+//  const SShape *sshape = (*v)->shape();
+//  for(;v!=vend;++v)
+//  {
+//    if((*v)->shape() != sshape)
+//      Exception::raiseException();
+//  }
+//  return sshape;
+//}
+
+// real Stroke::z_discontinuity(int iCombination) const 
+// {
+//   return z_discontinuity_edge_function<Stroke>(*this, iCombination);
+// }
+
+// Vec3r Stroke::curvature2d_as_vector(int iCombination) const 
+// {
+//   return curvature2d_as_vector_edge_function<Stroke>(*this, iCombination);
+// }
+
+// real Stroke::curvature2d_as_angle(int iCombination) const 
+// {
+//   return curvature2d_as_angle_edge_function<Stroke>(*this, iCombination);
+// }
+
+// float Stroke::shape_importance(int iCombination) const 
+// {
+//   return shape_importance_edge_function<Stroke>(*this, iCombination);
+// }
+
+
+// float Stroke::local_average_depth(int iCombination ) const
+// { 
+//   return local_average_depth_edge_function<Stroke >(*this, iCombination);
+// }
+
+// float Stroke::local_depth_variance(int iCombination) const
+// {
+//   return local_depth_variance_edge_function<Stroke>(*this, iCombination);
+// }
+
+// real Stroke::local_average_density(float sigma , int iCombination ) const 
+// {
+//   return density_edge_function<Stroke>(*this, iCombination);
+// }
diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h
new file mode 100755
index 00000000000..8e4e5e24a2c
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Stroke.h
@@ -0,0 +1,584 @@
+//
+//  Filename         : Stroke.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes to define a stroke
+//  Date of creation : 09/09/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKE_H
+# define STROKE_H
+
+# include <vector>
+# include <map>
+# include "../system/FreestyleConfig.h"
+# include "../view_map/Silhouette.h"
+# include "Curve.h"
+# include "../view_map/Interface1D.h"
+# include "../system/StringUtils.h"
+
+//
+//  StrokeAttribute
+//
+////////////////////////////////////////////////////////
+
+/*! Class to define an attribute associated to a Stroke Vertex.
+ *  This attribute stores the color, alpha and thickness values
+ *  for a Stroke Vertex.
+ */
+class LIB_STROKE_EXPORT StrokeAttribute
+{
+public:
+
+  /*! default constructor */
+  StrokeAttribute();
+  /*! Copy constructor */
+  StrokeAttribute(const StrokeAttribute& iBrother);
+  /*! Builds a stroke vertex attribute from 
+   *  a set of parameters.
+   *    \param iRColor
+   *      The Red Component value.
+   *    \param iGColor
+   *      The Green Component value.
+   *    \param iBColor
+   *      The Blue Component value.
+   *    \param iAlpha
+   *      The transparency value
+   *    \param iRThickness
+   *      The thickness of the stroke on the right
+   *    \param iLThickness
+   *      The Thickness of the stroke on the left
+   */
+  StrokeAttribute(float iRColor, float iGColor, float iBColor,
+                  float iAlpha,
+                  float iRThickness, float iLThickness);
+
+  /*! Interpolation constructor.
+   *  Builds a StrokeAttribute from two
+   *  StrokeAttributes and an interpolation parameter.
+   *  \param a1
+   *    The first Attribute.
+   *  \param a2
+   *    The second parameter.
+   *  \param t
+   *    The interpolation parameter.
+   */
+  StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t);
+
+  /*! destructor */
+  virtual ~StrokeAttribute();
+
+  /* operators */
+  /*! operator = */
+  StrokeAttribute& operator=(const StrokeAttribute& iBrother);
+  
+  /* accessors */
+  /*! Returns the attribute's color.
+   *  \return The array of 3 floats containing the R,G,B values
+   *  of the attribute's color.
+   */
+  inline const float* getColor()  const { return _color; }
+  /*! Returns the R color component. */
+  inline const float  getColorR() const { return _color[0]; }
+  /*! Returns the G color component. */
+  inline const float  getColorG() const { return _color[1]; }
+  /*! Returns the B color component. */
+  inline const float  getColorB() const { return _color[2]; }
+  /*! Returns the RGB color components. */
+  inline Vec3f  getColorRGB() const { return Vec3f(_color[0], _color[1], _color[2]); }
+  /*! Returns the alpha color component. */
+  inline float getAlpha() const { return _alpha; }
+  /*! Returns the attribute's thickness.
+   *  \return an array of 2 floats. the first value is
+   *  the thickness on the right of the vertex when following
+   *  the stroke, the second one is the thickness on the left.
+   */
+  inline const float* getThickness() const { return _thickness; }
+  /*! Returns the thickness on the right of the vertex when following the
+   *  stroke. */
+  inline const float  getThicknessR() const { return _thickness[0]; }
+  /*! Returns the thickness on the left of the vertex when following the
+   *  stroke. */
+  inline const float  getThicknessL() const { return _thickness[1]; }
+  /*! Returns the thickness on the right and on the left of the vertex when following the
+   *  stroke. */
+  inline Vec2f getThicknessRL() const { return Vec2f(_thickness[0], _thickness[1]); }
+
+  /*! Returns true if the strokevertex is visible, false otherwise */
+  inline bool isVisible() const {return _visible;}
+
+  /*! Returns an attribute of type real
+   *  \param iName
+   *    The name of the attribute
+   */
+  float getAttributeReal(const char *iName) const;
+  /*! Returns an attribute of type Vec2f
+   *  \param iName
+   *    The name of the attribute
+   */
+  Vec2f getAttributeVec2f(const char *iName) const;
+  /*! Returns an attribute of type Vec3f
+   *  \param iName
+   *    The name of the attribute
+   */
+  Vec3f getAttributeVec3f(const char *iName) const;
+
+  /*! Checks whether the attribute iName is availbale */
+  bool isAttributeAvailableReal(const char *iName) const ;
+  /*! Checks whether the attribute iName is availbale */
+  bool isAttributeAvailableVec2f(const char *iName) const ;
+  /*! Checks whether the attribute iName is availbale */
+  bool isAttributeAvailableVec3f(const char *iName) const ;
+  
+  /* modifiers */
+  /*! sets the attribute's color.
+   *    \param r
+   *      The new R value.
+   *    \param g
+   *      The new G value.
+   *    \param b
+   *      The new B value.
+   */
+  inline void setColor(float r, float g, float b) { _color[0]=r; _color[1]=g; _color[2]=b; }
+  /*! sets the attribute's color.
+   *    \param iRGB
+   *      The new RGB values.
+   */
+  inline void setColor(const Vec3f& iRGB) { _color[0]=iRGB[0]; _color[1]=iRGB[1]; _color[2]=iRGB[2]; }
+  /*! sets the attribute's alpha value.
+   *  \param alpha
+   *    The new alpha value.
+   */
+  inline void setAlpha(float alpha) { _alpha = alpha; }
+  /*! sets the attribute's thickness.
+   *  \param tr
+   *    The thickness on the right of the vertex when following the stroke.
+   *  \param tl
+   *    The thickness on the left of the vertex when following the stroke.
+   */
+  inline void setThickness(float tr, float tl) { _thickness[0]=tr; _thickness[1]=tl; }
+  /*! sets the attribute's thickness.
+   *  \param tRL
+   *    The thickness on the right and on the left of the vertex when following the stroke.
+   */
+  inline void setThickness(const Vec2f& tRL) { _thickness[0]=tRL[0]; _thickness[1]=tRL[1]; }
+
+  /*! sets the visible flag. True means visible. */
+  inline void setVisible(bool iVisible){ _visible = iVisible; }
+
+  /*! Adds a user defined attribute of type real
+   *  If there is no attribute of name iName, it is added.
+   *  Otherwise, the new value replaces the old one.
+   *  \param iName
+   *    The name of the attribute
+   *  \param att
+   *    The attribute's value
+   */
+  void setAttributeReal(const char *iName, float att);
+  /*! Adds a user defined attribute of type Vec2f
+   *  If there is no attribute of name iName, it is added.
+   *  Otherwise, the new value replaces the old one.
+   *  \param iName
+   *    The name of the attribute
+   *  \param att
+   *    The attribute's value
+   */
+  void setAttributeVec2f(const char *iName, const Vec2f& att);
+  /*! Adds a user defined attribute of type Vec3f
+   *  If there is no attribute of name iName, it is added.
+   *  Otherwise, the new value replaces the old one.
+   *  \param iName
+   *    The name of the attribute
+   *  \param att
+   *    The attribute's value
+   */
+  void setAttributeVec3f(const char *iName, const Vec3f& att);
+
+private:
+
+  typedef std::map<const char*, float, StringUtils::ltstr> realMap ;
+  typedef std::map<const char*, Vec2f, StringUtils::ltstr> Vec2fMap ;
+  typedef std::map<const char*, Vec3f, StringUtils::ltstr> Vec3fMap ;
+
+  float _color[3];      //! the color 
+  float _alpha;         //! alpha 
+  float _thickness[2];  //! the thickness on the right and on the left of the backbone vertex (the stroke is oriented)
+  bool _visible;
+  realMap *_userAttributesReal;
+  Vec2fMap *_userAttributesVec2f;
+  Vec3fMap *_userAttributesVec3f;
+};
+
+
+//
+//  StrokeVertex
+//
+////////////////////////////////////////////////////////
+
+/*! Class to define a stroke vertex.
+ */
+class LIB_STROKE_EXPORT StrokeVertex : public CurvePoint
+{
+public: // Implementation of Interface0D
+
+  /*! Returns the string "StrokeVertex"*/
+  virtual string getExactTypeName() const {
+    return "StrokeVertex";
+  }
+
+private:
+
+  StrokeAttribute _Attribute; //! The attribute associated to the vertex
+  float _CurvilignAbscissa; //! the curvilign abscissa
+  float _StrokeLength; // stroke length
+  
+public:
+
+  /*! default constructor */
+  StrokeVertex();
+  /*! Copy constructor */
+  StrokeVertex(const StrokeVertex& iBrother);
+  /*! Builds a stroke vertex from a SVertex */
+  StrokeVertex(SVertex *iSVertex);
+  /*! Builds a stroke vertex from a CurvePoint */
+  StrokeVertex(CurvePoint *iPoint);
+  /*! Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
+  StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);
+  /*! Builds a stroke from a view vertex and an attribute */
+  StrokeVertex(SVertex *iSVertex, const StrokeAttribute& iAttribute);
+  /*! destructor */
+  virtual ~StrokeVertex();
+  
+  /* operators */
+  /*! operator = */
+  StrokeVertex& operator=(const StrokeVertex& iBrother);
+  
+  /* accessors */
+  /*! Returns the 2D point x coordinate */
+  inline real x() const { return _Point2d[0]; }
+  /*! Returns the 2D point y coordinate */
+  inline real y() const { return _Point2d[1]; }
+  /*! Returns the 2D point coordinates as a Vec2d */
+  Vec2f getPoint () {return Vec2f((float)point2d()[0], (float)point2d()[1]);}
+  /*! Returns the ith 2D point coordinate (i=0 or 1)*/
+  inline real  operator[](const int i) const { return _Point2d[i]; }
+  /*! Returns the StrokeAttribute for this StrokeVertex */
+  inline const StrokeAttribute& attribute() const { return _Attribute; }
+  /*! Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
+  inline StrokeAttribute& attribute() {return _Attribute;}
+  /*! Returns the curvilinear abscissa */
+  inline float curvilinearAbscissa() const {return _CurvilignAbscissa;}
+  /*! Returns the length of the Stroke to which this StrokeVertex belongs */
+  inline float strokeLength() const {return _StrokeLength;}
+  /*! Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
+  inline float u() const {return _CurvilignAbscissa/_StrokeLength;}
+
+  /* modifiers */
+  /*! sets the 2D x value */
+  inline void setX(real x) { _Point2d[0]=x; }
+  /*! sets the 2D y value */
+  inline void setY(real y) { _Point2d[1]=y; }
+  /*! sets the 2D x and y values */
+  inline void setPoint(real x, real y) { _Point2d[0]=x; _Point2d[1]=y;}
+  /*! sets the 2D x and y values */
+  inline void setPoint(const Vec2f& p) { _Point2d[0] = p[0];_Point2d[1] = p[1];}
+  /*! Returns a reference to the ith 2D point coordinate (i=0 or 1) */
+  inline real& operator[](const int i) { return _Point2d[i]; }
+  /*! sets the attribute. */
+  inline void setAttribute(const StrokeAttribute& iAttribute) { _Attribute = iAttribute; }
+  /*! sets the curvilinear abscissa of this StrokeVertex in the Stroke */
+  inline void setCurvilinearAbscissa(float iAbscissa) {_CurvilignAbscissa = iAbscissa;}
+  /*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't
+   *  change the real Stroke's length.)
+   */
+  inline void setStrokeLength(float iLength) {_StrokeLength = iLength;}
+  
+  /* interface definition */
+  /* inherited */  
+  
+};
+
+
+//
+//  Stroke
+//
+////////////////////////////////////////////////////////
+
+class StrokeRenderer;
+class StrokeRep;
+
+namespace StrokeInternal {
+  class vertex_const_traits ;
+  class vertex_nonconst_traits ;
+  template<class Traits> class vertex_iterator_base;
+  class StrokeVertexIterator;
+} // end of namespace StrokeInternal
+
+/*! Class to define a stroke.
+ *  A stroke is made of a set of 2D vertices (StrokeVertex), regularly spaced out.
+ *  This set of vertices defines the stroke's backbone geometry.
+ *  Each of these stroke vertices defines the stroke's shape and appearance 
+ *  at this vertex position.
+ */
+class LIB_STROKE_EXPORT Stroke : public Interface1D
+{
+public: // Implementation of Interface1D
+
+  /*! Returns the string "Stroke" */
+  virtual string getExactTypeName() const {
+    return "Stroke";
+  }
+
+  // Data access methods
+
+  /*! Returns the Id of the Stroke */
+  virtual Id getId() const {
+    return _id;
+  }
+  /*! The different blending modes
+   *  available to similate the interaction
+   *  media-medium.
+   */
+  typedef enum{
+    DRY_MEDIUM,/*!< To simulate a dry medium such as Pencil or Charcoal.*/
+    HUMID_MEDIUM,/*!< To simulate ink painting (color substraction blending).*/
+    OPAQUE_MEDIUM,  /*!< To simulate an opaque medium (oil, spray...).*/
+  } MediumType;
+
+  
+public:
+  typedef std::deque<StrokeVertex*> vertex_container; // the vertices container
+  typedef std::vector<ViewEdge*> viewedge_container; // the viewedges container
+  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_nonconst_traits > vertex_iterator;
+  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_const_traits> const_vertex_iterator;
+
+public:
+  //typedef StrokeVertex                                        vertex_type;
+private:
+  vertex_container _Vertices; //! The stroke's backbone vertices
+  Id _id;
+  float _Length; // The stroke length
+  viewedge_container _ViewEdges;
+  float _sampling;
+  StrokeRenderer *_renderer; // mark implementation OpenGL renderer
+  MediumType _mediumType;
+  unsigned int _textureId;
+  bool _tips;
+  Vec2r _extremityOrientations[2]; // the orientations of the first and last extermity
+  StrokeRep *_rep;
+
+public:
+  /*! default constructor */
+  Stroke();
+  /*! copy constructor */
+  Stroke(const Stroke& iBrother);
+  /*! Builds a stroke from a set of StrokeVertex.
+   *  This constructor is templated by an iterator type.
+   *  This iterator type must allow the vertices parsing
+   *  using the ++ operator.
+   *    \param iBegin
+   *      The iterator pointing to the first vertex.
+   *    \param iEnd
+   *      The iterator pointing to the end of the vertex list. 
+   */
+  template<class InputVertexIterator>
+  Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);
+
+  /*! Destructor */
+  virtual ~Stroke();
+  
+  /* operators */
+  /*! operator = */
+  Stroke& operator=(const Stroke& iBrother);
+
+  /*! Compute the sampling needed to get iNVertices
+   *  vertices.
+   *  If the specified number of vertices is less than the
+   *  actual number of vertices, the actual sampling value is returned.
+   *  (To remove Vertices, use the RemoveVertex() method of this class).
+   *  \param iNVertices
+   *    The number of StrokeVertices we eventually want
+   *    in our Stroke.
+   *  \return the sampling that must be used in the Resample(float) method.
+   *  @see Resample(int)
+   *  @see Resample(float)
+   */
+  float ComputeSampling(int iNVertices);
+  
+  /*! Resampling method.
+   *  Resamples the curve so that it eventually
+   *  has iNPoints. That means it is going 
+   *  to add iNPoints-vertices_size, if vertices_size
+   *  is the number of points we already have.
+   *  Is vertices_size >= iNPoints, no resampling is done.
+   *  \param iNPoints
+   *    The number of vertices we eventually want in our stroke.
+   */
+  void Resample(int iNPoints);
+
+  /*! Resampling method.
+   *  Resamples the curve with a given sampling.
+   *  If this sampling is < to the actual sampling
+   *  value, no resampling is done.
+   *  \param iSampling
+   *    The new sampling value.  
+   */
+  void Resample(float iSampling);
+
+  /*! Removes the stroke vertex iVertex 
+   *  from the stroke.
+   *  The length and curvilinear abscissa are updated
+   *  consequently.
+   */
+  void RemoveVertex(StrokeVertex *iVertex);
+
+  /*! Inserts the stroke vertex iVertex 
+   *  in the stroke before next.
+   *  The length, curvilinear abscissa are updated
+   *  consequently.
+   *  \param iVertex
+   *    The StrokeVertex to insert in the Stroke.
+   *  \param next
+   *    A StrokeVertexIterator pointing to the StrokeVeretx before
+   *    which iVertex must be inserted.
+   */
+  void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);
+
+  /* Render method */
+  void Render(const StrokeRenderer *iRenderer );
+  void RenderBasic(const StrokeRenderer *iRenderer );
+
+  /* Iterator definition */
+  
+  /* accessors */
+  /*! Returns the 2D length of the Stroke */
+  inline real getLength2D() const {return _Length;}
+  /*! Returns a reference to the time stamp value of the stroke. */
+  /*! Returns the MediumType used for this Stroke. */
+  inline MediumType getMediumType() const {return _mediumType;}
+  /*! Returns the id of the texture used to simulate th marks system
+   *  for this Stroke
+   */
+  inline unsigned int getTextureId() {return _textureId;}
+  /*! Returns true if this Stroke uses a texture with tips, false
+   *  otherwise.
+   */
+  inline bool hasTips() const {return _tips;}
+  /* these advanced iterators are used only in C++ */
+  inline int vertices_size() const {return _Vertices.size();}
+  inline viewedge_container::const_iterator viewedges_begin() const {return _ViewEdges.begin();}
+  inline viewedge_container::iterator viewedges_begin()  {return _ViewEdges.begin();}
+  inline viewedge_container::const_iterator viewedges_end() const {return _ViewEdges.end();}
+  inline viewedge_container::iterator viewedges_end()  {return _ViewEdges.end();}
+  inline int viewedges_size() const {return _ViewEdges.size();}
+  
+  inline Vec2r getBeginningOrientation() const {return _extremityOrientations[0];}
+  inline real getBeginningOrientationX() const {return _extremityOrientations[0].x();}
+  inline real getBeginningOrientationY() const {return _extremityOrientations[0].y();}
+  inline Vec2r getEndingOrientation() const {return _extremityOrientations[1];}
+  inline real getEndingOrientationX() const {return _extremityOrientations[1].x();}
+  inline real getEndingOrientationY() const {return _extremityOrientations[1].y();}
+
+
+  /* modifiers */
+  /*! sets the Id of the Stroke. */
+  inline void setId(const Id& id) {_id = id;}
+  /*! sets the 2D length of the Stroke. */
+  void setLength(float iLength);
+  /*! sets the medium type that must be used for this Stroke. */
+  inline void setMediumType(MediumType iType) {_mediumType = iType;}
+  /*! sets the texture id to be used to simulate the marks system for this Stroke. */
+  inline void setTextureId(unsigned int id) {_textureId = id;}
+  /*! sets the flag telling whether this stroke is using a texture with
+   *  tips or not.
+   */
+  inline void setTips(bool iTips) {_tips = iTips;}
+  
+  inline void push_back(StrokeVertex* iVertex) { _Vertices.push_back(iVertex); }
+  inline void push_front(StrokeVertex* iVertex) { _Vertices.push_front(iVertex); }
+  inline void AddViewEdge(ViewEdge *iViewEdge) {_ViewEdges.push_back(iViewEdge);}
+  inline void setBeginningOrientation(const Vec2r& iOrientation) {_extremityOrientations[0] = iOrientation;}
+  inline void setBeginningOrientation(real x, real y) {_extremityOrientations[0] = Vec2r(x,y);}
+  inline void setEndingOrientation(const Vec2r& iOrientation) {_extremityOrientations[1] = iOrientation;}
+  inline void setEndingOrientation(real x, real y) {_extremityOrientations[1] = Vec2r(x,y);}
+
+  /* Information access interface */
+  
+  // embedding vertex iterator
+  const_vertex_iterator vertices_begin() const;
+  vertex_iterator vertices_begin(float t=0.f);
+  const_vertex_iterator vertices_end() const;
+  vertex_iterator vertices_end();
+
+  /*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the
+   *  Stroke. One can specifly a sampling value to resample the Stroke
+   *  on the fly if needed.
+   *  \param t
+   *    The resampling value with which we want our Stroke to be resampled.
+   *    If 0 is specified, no resampling is done.
+   */
+  StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t=0.f);
+  /*! Returns a StrokeVertexIterator pointing after the last StrokeVertex of the
+   *  Stroke.
+   */
+  StrokeInternal::StrokeVertexIterator strokeVerticesEnd();
+  /*! Returns the number of StrokeVertex constituing the Stroke. */
+  inline unsigned int strokeVerticesSize() const {return _Vertices.size();}
+  
+  // Iterator access (Interface1D)
+  /*! Returns an Interface0DIterator pointing on the first StrokeVertex of the
+   *  Stroke.
+   */
+  virtual Interface0DIterator verticesBegin();
+  /*! Returns an Interface0DIterator pointing after the last StrokeVertex of the
+   *  Stroke.
+   */
+  virtual Interface0DIterator verticesEnd();
+
+  virtual Interface0DIterator pointsBegin(float t=0.f);
+  virtual Interface0DIterator pointsEnd(float t=0.f);
+};
+
+
+
+//
+//  Implementation
+//
+////////////////////////////////////////////////////////
+
+
+template<class InputVertexIterator>
+Stroke::Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd)
+{
+  for(InputVertexIterator v=iBegin, vend=iEnd;
+  v!=vend;
+  v++)
+  {
+    _Vertices.push_back(*v);
+  }
+  _Length = 0;
+  _id = 0;
+}
+
+#endif // STROKE_H
diff --git a/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
new file mode 100755
index 00000000000..279a0b12089
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h
@@ -0,0 +1,142 @@
+//
+//  Filename         : StrokeAdvancedIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the elements of the Stroke
+//                     Can't be used in python
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKEADVANCEDITERATORS_H
+# define STROKEADVANCEDITERATORS_H
+
+# include "Stroke.h"
+
+namespace StrokeInternal {
+
+  class vertex_const_traits : public Const_traits<StrokeVertex*> {
+  public:
+    typedef std::deque<StrokeVertex*> vertex_container; 
+    typedef vertex_container::const_iterator vertex_container_iterator ;
+  };
+  class vertex_nonconst_traits : public Nonconst_traits<StrokeVertex*> {
+  public:
+    typedef std::deque<StrokeVertex*> vertex_container; //! the vertices container
+    typedef vertex_container::iterator vertex_container_iterator ;
+  };
+
+
+  template<class Traits>
+    class vertex_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
+  {
+  public:
+    typedef vertex_iterator_base<Traits>  Self;
+  protected:
+    typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
+    typedef typename Traits::vertex_container_iterator vertex_container_iterator;
+    typedef vertex_iterator_base<vertex_nonconst_traits> iterator;
+    typedef vertex_iterator_base<vertex_const_traits> const_iterator;
+    //protected:
+  public:
+    vertex_container_iterator _it;
+    vertex_container_iterator _begin;
+    vertex_container_iterator _end;
+  public:
+    friend class Stroke;
+    //friend class vertex_iterator;
+    inline vertex_iterator_base()
+      : parent_class()
+    {}
+    inline vertex_iterator_base(const iterator& iBrother) 
+      : parent_class()
+    {_it = iBrother._it;_begin = iBrother._begin;_end = iBrother._end;} 
+    inline vertex_iterator_base(const const_iterator& iBrother) 
+      : parent_class()
+    {_it = iBrother._it;_begin = iBrother._begin;_end = iBrother._end;} 
+  //protected://FIXME
+  public:
+    inline vertex_iterator_base(vertex_container_iterator it, vertex_container_iterator begin, vertex_container_iterator end)
+      : parent_class()
+    {
+      _it = it;
+      _begin = begin;
+      _end = end;
+    }
+    
+  public:
+    virtual ~vertex_iterator_base() {}
+    
+    virtual bool begin() const {return _it==_begin? true : false;}
+    virtual bool end() const {return _it==_end ? true : false;}
+    
+    // operators
+    inline Self& operator++()  // operator corresponding to ++i
+    { 
+      ++_it;
+      return *(this);
+    }
+    inline Self operator++(int)  // opérateur correspondant à i++ 
+    {
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      ++_it;                    // dans un temporaire. 
+      return tmp;
+    }
+    inline Self& operator--()  // operator corresponding to ++i
+    { 
+      --_it;
+      return *(this);
+    }
+    inline Self operator--(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      --_it;                    // dans un temporaire. 
+      return tmp;
+    }
+    
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      return (_it != b._it);
+    }
+    virtual bool operator==(const Self& b) const
+    {
+      return !(*this != b);
+    }
+    
+    // dereferencing
+    virtual typename Traits::reference operator*() const  {return *(_it);}
+    virtual typename Traits::pointer operator->() const { return &(operator*());}
+    
+    /*! accessors */
+    inline vertex_container_iterator it() const {return _it;}
+    inline vertex_container_iterator getBegin() const {return _begin;}
+    inline vertex_container_iterator getEnd() const {return _end;}
+  };
+
+} // end of namespace StrokeInternal
+
+
+#endif // STROKEADVANCEDITERATORS_H
+
+
diff --git a/source/blender/freestyle/intern/stroke/StrokeIO.cpp b/source/blender/freestyle/intern/stroke/StrokeIO.cpp
new file mode 100755
index 00000000000..7f540939fa1
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeIO.cpp
@@ -0,0 +1,55 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "StrokeIO.h"
+#include "StrokeAdvancedIterators.h"
+
+
+ostream& operator<<(ostream& out, const StrokeAttribute& iStrokeAttribute){
+  out << "    StrokeAttribute" << endl;
+  out << "      color     : (" << iStrokeAttribute.getColorR() << "," << iStrokeAttribute.getColorG() << "," << iStrokeAttribute.getColorB() << ")" << endl;
+  out << "      alpha     : " << iStrokeAttribute.getAlpha() << endl;
+  out << "      thickness : " << iStrokeAttribute.getThicknessR() << ", " << iStrokeAttribute.getThicknessL() << endl;
+  out << "      visible   : " << iStrokeAttribute.isVisible() << endl;
+  return out;
+}
+
+ostream& operator<<(ostream& out, const StrokeVertex& iStrokeVertex){
+  out << "  StrokeVertex" << endl;
+  out << "    id                 : " << iStrokeVertex.getId() << endl;
+  out << "    curvilinear length : " << iStrokeVertex.curvilinearAbscissa() << endl;
+  out << "    2d coordinates     : (" << iStrokeVertex.getProjectedX() << "," << iStrokeVertex.getProjectedY() << "," << iStrokeVertex.getProjectedZ() << ")" << endl;
+  out << "    3d coordinates     : (" << iStrokeVertex.getX() << "," << iStrokeVertex.getY() << "," << iStrokeVertex.getZ() << ")"<< endl;
+  out << iStrokeVertex.attribute() << endl;
+  return out;
+}
+
+ostream& operator<<(ostream& out, const Stroke& iStroke){
+  out << "Stroke" << endl;
+  out << "  id          : " << iStroke.getId() << endl;
+  out << "  length      : " << iStroke.getLength2D() << endl;
+  out << "  medium type : " << iStroke.getMediumType() << endl;
+  for(Stroke::const_vertex_iterator v=iStroke.vertices_begin(), vend=iStroke.vertices_end();
+    v!=vend;
+  ++v){
+    out << *(*v) << endl;
+  }
+  return out;
+}
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/stroke/StrokeIO.h b/source/blender/freestyle/intern/stroke/StrokeIO.h
new file mode 100755
index 00000000000..42b99420f4a
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeIO.h
@@ -0,0 +1,47 @@
+//
+//  Filename         : StrokeIO.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Functions to manage I/O for the stroke
+//  Date of creation : 03/02/2004
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKEIO_H
+# define STROKEIO_H
+
+# include <iostream>
+# include "../system/FreestyleConfig.h"
+# include "Stroke.h"
+
+LIB_STROKE_EXPORT
+ostream& operator<<(ostream& out, const StrokeAttribute& iStrokeAttribute);
+
+LIB_STROKE_EXPORT
+ostream& operator<<(ostream& out, const StrokeVertex& iStrokeVertex);
+
+LIB_STROKE_EXPORT
+ostream& operator<<(ostream& out, const Stroke& iStroke);
+
+
+#endif // STROKEIO_H
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/stroke/StrokeIterators.h b/source/blender/freestyle/intern/stroke/StrokeIterators.h
new file mode 100755
index 00000000000..9cc08a0532a
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeIterators.h
@@ -0,0 +1,227 @@
+//
+//  Filename         : StrokeIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the elements of the Stroke
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKEITERATORS_H
+# define STROKEITERATORS_H
+
+# include "Stroke.h"
+
+namespace StrokeInternal {
+
+  //
+  // StrokeVertexIterator
+  //
+  /////////////////////////////////////////////////
+
+  /*! Class defining an iterator designed to iterate over
+   *  the StrokeVertex of a Stroke.
+   *  An instance of a StrokeVertexIterator can only be obtained
+   *  from a Stroke by calling strokeVerticesBegin() or strokeVerticesEnd().
+   *  It is iterating over the same vertices as an Interface0DIterator.
+   *  The difference resides in the object access. Indeed, an Interface0DIterator
+   *  allows only an access to an Interface0D whereas we could need
+   *  to access the specialized StrokeVertex type. In this case, one
+   *  should use a StrokeVertexIterator.
+   *  The castToInterface0DIterator() method is useful to get an Interface0DIterator
+   *  from a StrokeVertexIterator in order to call any functions of the
+   *  type UnaryFunction0D.
+   *  \attention In the scripting language, you must call
+   *  \code it2 = StrokeVertexIterator(it1) \endcode instead of
+   *  \code it2 = it1 \endcode
+   *  where \a it1 and \a it2 are 2 StrokeVertexIterator.
+   *  Otherwise, incrementing \a it1 will also increment \a it2.
+   */
+  class StrokeVertexIterator : public Interface0DIteratorNested
+  {
+  public:
+
+    /*! Default constructor. */
+    StrokeVertexIterator() {}
+
+    /*! Copy constructor. */
+    StrokeVertexIterator(const StrokeVertexIterator& vi) {
+      _it = vi._it;
+      _begin = vi._begin;
+      _end = vi._end;
+    }
+
+    StrokeVertexIterator(const ::Stroke::vertex_container::iterator& it,
+			 const ::Stroke::vertex_container::iterator& begin,
+			 const ::Stroke::vertex_container::iterator& end) {
+      _it = it;
+      _begin = begin;
+      _end = end;
+    }
+
+    virtual ~StrokeVertexIterator() {}
+
+    /*! Casts this StrokeVertexIterator into an Interface0DIterator.
+     *  Useful for any call to a function of the type UnaryFunction0D.
+     */
+    inline Interface0DIterator castToInterface0DIterator() const {
+      Interface0DIterator ret(new StrokeVertexIterator(*this));
+      return ret;
+    }
+    /*! operator=
+     *  \attention In the scripting language, you must call
+     *  \code it2 = StrokeVertexIterator(it1) \endcode instead of
+     *  \code it2 = it1 \endcode
+     *  where \a it1 and \a it2 are 2 StrokeVertexIterator.
+     *  Otherwise, incrementing \a it1 will also increment \a it2.
+     *  
+     */
+    StrokeVertexIterator& operator=(const StrokeVertexIterator& vi) {
+      _it = vi._it;
+      _begin = vi._begin;
+      _end = vi._end;
+      return *this;
+    }
+
+    /*! Returns the string "StrokeVertexIterator". */
+    virtual string getExactTypeName() const {
+      return "StrokeVertexIterator";
+    }
+
+    /*! Returns a reference to the pointed StrokeVertex.
+     *  In the scripting language, you must call
+     *  "getObject()"instead.
+     */
+    virtual StrokeVertex& operator*() {
+      return **_it;
+    }
+
+    /*! Returns a pointer to the pointed StrokeVertex.
+     * Can't be called in the scripting language.
+     */
+    virtual StrokeVertex* operator->() {
+      return &(operator*());
+    }
+
+    /*! Increments. In the scripting language, call
+     *  "increment()".
+     */
+    virtual StrokeVertexIterator& operator++() {
+      increment();
+      return *this;
+    }
+
+    /*! Increments. In the scripting language, call
+     *  "increment()".
+     */
+    virtual StrokeVertexIterator operator++(int) {
+      StrokeVertexIterator ret(*this);
+      increment();
+      return ret;
+    }
+
+    /*! Decrements. In the scripting language, call
+     *  "decrement()".
+     */
+    virtual StrokeVertexIterator& operator--() {
+      decrement();
+      return *this;
+    }
+
+    /*! Decrements. In the scripting language, call
+     *  "decrement()".
+     */
+    virtual StrokeVertexIterator operator--(int) {
+      StrokeVertexIterator ret(*this);
+      decrement();
+      return ret;
+    }
+
+    /*! Increments. */
+    virtual void increment() {
+      ++_it;
+    }
+
+    /*! Decrements. */
+    virtual void decrement() {
+      --_it;
+    }
+
+    /*! Returns true if the pointed StrokeVertex is the
+     * first of the Stroke.
+     */
+    bool isBegin() const {
+      return _it == _begin;
+    }
+
+    /*! Returns true if the pointed StrokeVertex is after the
+     * last StrokeVertex of the Stroke.
+     */
+    bool isEnd() const {
+      return _it == _end;
+    }
+
+    /*! operator == */
+    virtual bool operator==(const Interface0DIteratorNested& it) const {
+      const StrokeVertexIterator* it_exact = dynamic_cast<const StrokeVertexIterator*>(&it);
+      if (!it_exact)
+	return false;
+      return (_it == it_exact->_it);
+    }
+
+    /*! Returns the curvilinear abscissa of the current point */
+    virtual float t() const{
+      return (*_it)->curvilinearAbscissa();
+    }
+    /*! Returns the point's parameter in the stroke */
+    virtual float u() const{
+      return (*_it)->u();
+    }
+
+    /*! Cloning method */
+    virtual StrokeVertexIterator* copy() const {
+      return new StrokeVertexIterator(*this);
+    }
+
+  //
+  // Not exported in Python
+  //
+  //////////////////////////////////////////////////
+
+    const ::Stroke::vertex_container::iterator& getIt() {
+    return _it;
+  }
+
+  private:
+
+    ::Stroke::vertex_container::iterator _it;
+    ::Stroke::vertex_container::iterator _begin;
+    ::Stroke::vertex_container::iterator _end;
+  };
+
+} // end of namespace StrokeInternal
+
+
+#endif // STROKEITERATORS_H
+
+
diff --git a/source/blender/freestyle/intern/stroke/StrokeLayer.cpp b/source/blender/freestyle/intern/stroke/StrokeLayer.cpp
new file mode 100755
index 00000000000..8b469399ca8
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeLayer.cpp
@@ -0,0 +1,55 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "StrokeLayer.h"
+#include "Stroke.h"
+#include "Canvas.h"
+
+StrokeLayer::~StrokeLayer()
+{
+  clear();
+}
+
+void StrokeLayer::Render(const StrokeRenderer *iRenderer )
+{
+  for(StrokeLayer::stroke_container::iterator s=_strokes.begin(), send=_strokes.end();
+      s!=send;
+      ++s){
+      (*s)->Render(iRenderer);
+  } 
+}
+
+void StrokeLayer::RenderBasic(const StrokeRenderer *iRenderer )
+{
+  for(StrokeLayer::stroke_container::iterator s=_strokes.begin(), send=_strokes.end();
+      s!=send;
+      ++s){
+      (*s)->RenderBasic(iRenderer);
+      }
+}
+void StrokeLayer::clear()
+{
+  for(stroke_container::iterator s=_strokes.begin(), send=_strokes.end();
+      s!=send;
+      ++s)
+    delete *s;
+  _strokes.clear();
+}
diff --git a/source/blender/freestyle/intern/stroke/StrokeLayer.h b/source/blender/freestyle/intern/stroke/StrokeLayer.h
new file mode 100755
index 00000000000..dbe9ea5a75c
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeLayer.h
@@ -0,0 +1,75 @@
+//
+//  Filename         : StrokeLayer.h
+//  Author           : Stephane Grabli
+//  Purpose          : Class to define a layer of strokes.
+//  Date of creation : 18/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKELAYER_H
+# define STROKELAYER_H
+
+# include <deque>
+
+class Stroke;
+class StrokeRenderer;
+class StrokeLayer 
+{
+public:
+  typedef std::deque<Stroke*> stroke_container;
+
+protected:
+  stroke_container _strokes;
+public:
+  StrokeLayer() {}
+  StrokeLayer(const stroke_container& iStrokes)
+  {
+    _strokes = iStrokes;
+  }
+  StrokeLayer(const StrokeLayer& iBrother)
+  {
+    _strokes = iBrother._strokes;
+  }
+  virtual ~StrokeLayer() ;
+
+  /*! Render method */
+  void Render(const StrokeRenderer *iRenderer );
+  void RenderBasic(const StrokeRenderer *iRenderer );
+
+  /*! clears the layer */
+  void clear() ;
+
+  /*! accessors */
+  inline stroke_container::iterator strokes_begin() {return _strokes.begin();}
+  inline stroke_container::iterator strokes_end() {return _strokes.end();}
+  inline int strokes_size() const {return _strokes.size();}
+  inline bool empty() const {return _strokes.empty();}
+
+  /*! modifiers */
+  inline void setStrokes(stroke_container& iStrokes) {_strokes = iStrokes;}
+  inline void AddStroke(Stroke *iStroke) {_strokes.push_back(iStroke);}
+  
+};
+
+#endif // STROKELAYER_H
diff --git a/source/blender/freestyle/intern/stroke/StrokeRenderer.cpp b/source/blender/freestyle/intern/stroke/StrokeRenderer.cpp
new file mode 100755
index 00000000000..e747fb4f5cd
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeRenderer.cpp
@@ -0,0 +1,146 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "StrokeRenderer.h"
+#include "../geometry/GeomUtils.h"
+using namespace std;
+
+/**********************************/
+/*                                */
+/*                                */
+/*         StrokeRenderer         */
+/*                                */
+/*                                */
+/**********************************/
+
+LIB_STROKE_EXPORT
+TextureManager *StrokeRenderer::_textureManager = 0;
+
+StrokeRenderer::StrokeRenderer ()
+{
+} 
+
+StrokeRenderer::~StrokeRenderer ()
+{
+}
+
+bool StrokeRenderer::loadTextures()
+{
+  _textureManager->load();
+  return true;
+}
+
+// unsigned int StrokeRenderer::getPaperTextureIndex(unsigned int index)
+// {
+  // return _textureManager->getPaperTextureIndex(index);
+// }
+
+
+/**********************************/
+/*                                */
+/*                                */
+/*         TextureManager         */
+/*                                */
+/*                                */
+/**********************************/
+
+
+LIB_STROKE_EXPORT
+TextureManager* TextureManager::_pInstance = 0;
+
+LIB_STROKE_EXPORT
+vector<string> TextureManager::_papertextures;
+
+LIB_STROKE_EXPORT
+string TextureManager::_patterns_path;
+
+LIB_STROKE_EXPORT
+string TextureManager::_brushes_path;
+
+TextureManager::TextureManager ()
+{
+  _papertexname = NULL;
+  _hasLoadedTextures=false;
+  _pInstance = this;
+  _defaultTextureId = 0;
+}
+
+TextureManager::~TextureManager ()
+{
+  if (_papertexname)
+    delete _papertexname;
+  if(!_brushesMap.empty())
+    _brushesMap.clear();
+  _pInstance = 0;
+}
+
+void TextureManager::load()
+{
+  if(_hasLoadedTextures)
+    return ;
+  loadPapers();
+  loadStandardBrushes();
+  _hasLoadedTextures = true;
+}
+
+unsigned TextureManager::getBrushTextureIndex(string name, Stroke::MediumType loadingMode)
+{
+  BrushTexture bt(name,loadingMode);
+  brushesMap::iterator b = _brushesMap.find(bt);
+  if(b == _brushesMap.end()){
+      unsigned texId = loadBrush(name, loadingMode);
+      _brushesMap[bt] = texId;
+      return texId;
+      cout << "brush file " << name << " not found" << endl;
+      return 0;
+  }else{
+    return _brushesMap[bt];
+  }
+}
+
+vector<string>& TextureManager::Options::getPaperTextures() {
+  return _papertextures;
+}
+
+void TextureManager::Options::setPaperTextures(const vector<string>& sl) {
+  _papertextures = sl;
+}
+
+void TextureManager::Options::setPatternsPath(const string& path) {
+  _patterns_path = path;
+}
+
+string TextureManager::Options::getPatternsPath() {
+  return _patterns_path;
+}
+
+void TextureManager::Options::setBrushesPath(const string& path) {
+  _brushes_path = path;
+}
+
+string TextureManager::Options::getBrushesPath() {
+  return _brushes_path;
+}
+
+unsigned TextureManager::getPaperTexturesNumber() {
+  return _papertextures.size();
+}
+
diff --git a/source/blender/freestyle/intern/stroke/StrokeRenderer.h b/source/blender/freestyle/intern/stroke/StrokeRenderer.h
new file mode 100755
index 00000000000..d192fe30145
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeRenderer.h
@@ -0,0 +1,140 @@
+//
+//  Filename         : StrokeRenderer.h
+//  Author(s)        : Fredo Durand
+//  Purpose          : Classes to render a stroke with OpenGL
+//  Date of creation : 09/09/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKE_RENDERER_H
+# define STROKE_RENDERER_H
+
+# include <vector>
+# include <map>
+# include <utility>
+# include "../system/FreestyleConfig.h"
+# include "Stroke.h"
+# include "StrokeRep.h"
+# include <string.h>
+
+
+/**********************************/
+/*                                */
+/*                                */
+/*         TextureManager         */
+/*                                */
+/*                                */
+/**********************************/
+
+
+/*! Class to load textures
+ */
+class LIB_STROKE_EXPORT TextureManager
+{
+public:
+
+  TextureManager ();
+  virtual ~TextureManager ();
+  static TextureManager * getInstance() {return _pInstance;}
+  void load () ;
+  unsigned getBrushTextureIndex(string name, Stroke::MediumType iType = Stroke::OPAQUE_MEDIUM) ;
+  unsigned getPaperTextureIndex(unsigned i) { return _papertexname[i]; }
+
+  static unsigned getPaperTexturesNumber();
+  inline bool hasLoaded() const {return _hasLoadedTextures;}
+  inline unsigned int getDefaultTextureId() const {return _defaultTextureId;}
+
+  struct LIB_STROKE_EXPORT Options
+  {
+    static void setPaperTextures(const vector<string>& sl);
+    static vector<string>& getPaperTextures();
+
+    static void setPatternsPath(const string& path);
+    static string getPatternsPath();
+
+    static void setBrushesPath(const string& path);
+    static string getBrushesPath();
+  };
+
+ protected:
+  virtual void loadPapers() = 0;
+  virtual void loadStandardBrushes() = 0;
+  virtual unsigned loadBrush(string fileName, Stroke::MediumType = Stroke::OPAQUE_MEDIUM) = 0;
+  
+  typedef std::pair<string,Stroke::MediumType> BrushTexture;
+  struct cmpBrushTexture{
+    bool operator()(const BrushTexture& bt1, const BrushTexture& bt2) const{
+      int r = strcmp(bt1.first.c_str(), bt2.first.c_str());
+      if(r != 0)
+        return (r<0);
+      else
+        return (bt1.second < bt2.second);
+    }
+  };
+  typedef std::map<BrushTexture, unsigned, cmpBrushTexture> brushesMap;
+
+  static TextureManager * _pInstance;
+  bool                  _hasLoadedTextures;
+  brushesMap            _brushesMap;
+  unsigned*		_papertexname;
+  static string		_patterns_path;
+  static string		_brushes_path;
+  static vector<string>	_papertextures;
+  unsigned int _defaultTextureId;
+};
+
+
+/**********************************/
+/*                                */
+/*                                */
+/*         StrokeRenderer         */
+/*                                */
+/*                                */
+/**********************************/
+
+/*! Class to render a stroke. 
+  Creates a triangle strip and stores it
+  strip is lazily created at the first rendering
+*/
+class LIB_STROKE_EXPORT StrokeRenderer
+{
+ public:
+  StrokeRenderer();
+  virtual ~StrokeRenderer ();
+
+  /*! Renders a stroke rep */
+  virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const = 0;
+  virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const = 0;
+
+  // initializes the texture manager
+  // lazy, checks if it has already been done
+  static bool loadTextures() ;
+  
+  //static unsigned int getTextureIndex(unsigned int index)  ;
+  //static unsigned int getPaperTextureIndex(unsigned int index)  ;
+  static TextureManager *_textureManager;
+};
+
+
+#endif // STROKE_RENDERER_H
diff --git a/source/blender/freestyle/intern/stroke/StrokeRep.cpp b/source/blender/freestyle/intern/stroke/StrokeRep.cpp
new file mode 100755
index 00000000000..51a1c8cfd4d
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeRep.cpp
@@ -0,0 +1,820 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "StrokeRep.h"
+#include "Stroke.h"
+#include "StrokeRenderer.h"
+#include "StrokeAdvancedIterators.h"
+#include "StrokeIterators.h"
+
+using namespace std;
+
+//
+// STROKE VERTEX REP
+/////////////////////////////////////
+StrokeVertexRep::StrokeVertexRep(const StrokeVertexRep& iBrother){
+  _point2d = iBrother._point2d;
+  _texCoord = iBrother._texCoord;
+  _color = iBrother._color;
+  _alpha = iBrother._alpha;
+}
+
+//
+// STRIP
+/////////////////////////////////////
+
+Strip::Strip(const vector<StrokeVertex*>& iStrokeVertices, bool hasTips, bool beginTip, bool endTip){
+  createStrip(iStrokeVertices);
+  if (!hasTips)
+	  computeTexCoord (iStrokeVertices);
+  else
+	  computeTexCoordWithTips (iStrokeVertices, beginTip, endTip);
+}
+Strip::Strip(const Strip& iBrother){
+  if(!iBrother._vertices.empty()){
+    for(vertex_container::const_iterator v=iBrother._vertices.begin(), vend=iBrother._vertices.end();
+    v!=vend;
+    ++v){
+      _vertices.push_back(new StrokeVertexRep(**v));
+    }
+  }
+  _averageThickness = iBrother._averageThickness;
+}
+
+Strip::~Strip(){
+  if(!_vertices.empty()){
+    for(vertex_container::iterator v=_vertices.begin(), vend=_vertices.end();
+    v!=vend;
+    ++v){
+      delete (*v);
+    }
+    _vertices.clear();
+  }
+}
+
+//////////////////////////
+// Strip creation
+//////////////////////////
+#define EPS_SINGULARITY_RENDERER 0.05
+#define ZERO 0.00001
+#define MAX_RATIO_LENGTH_SINGU 2
+#define HUGE_COORD 1e4
+
+bool notValid (Vec2r p)
+{
+  return (p[0]!=p[0]) || (p[1]!=p[1]) || (fabs(p[0])>HUGE_COORD) || (fabs(p[1])>HUGE_COORD) 
+    || (p[0] <-HUGE_COORD) || (p[1]<-HUGE_COORD);
+}
+
+real crossP(const Vec2r& A, const Vec2r& B){
+  return A[0]*B[1] - A[1]*B[0];
+}
+
+void
+Strip::createStrip (const vector<StrokeVertex*>& iStrokeVertices)
+{
+  //computeParameterization();
+  if (iStrokeVertices.size() <2) 
+    {
+      cerr << "Warning: strip has less than 2 vertices" << endl;
+      return;
+    }
+  _vertices.reserve(2*iStrokeVertices.size());
+  if(!_vertices.empty()){
+    for(vertex_container::iterator v=_vertices.begin(), vend=_vertices.end();
+    v!=vend;
+    ++v){
+      delete (*v);
+    }
+    _vertices.clear();
+  }
+  _averageThickness=0.0;
+
+  vector<StrokeVertex*>::const_iterator v ,vend, v2, vPrev;
+  StrokeVertex *sv, *sv2, *svPrev;
+
+  //special case of first vertex
+  v=iStrokeVertices.begin();
+  sv=*v;
+  vPrev=v; //in case the stroke has only 2 vertices;
+  ++v; sv2=*v;
+  Vec2r dir(sv2->getPoint()-sv->getPoint());
+  Vec2r orthDir(-dir[1], dir[0]);
+  if (orthDir.norm() > ZERO)
+    orthDir.normalize();
+   const float *thickness =  sv->attribute().getThickness();
+  _vertices.push_back(new StrokeVertexRep(sv->getPoint()+thickness[1]*orthDir)); 
+  _vertices.push_back(new StrokeVertexRep(sv->getPoint()-thickness[0]*orthDir)); 
+
+  Vec2r stripDir(orthDir);
+  // check whether the orientation
+  // was user defined
+  if(sv->attribute().isAttributeAvailableVec2f("orientation")){
+    Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
+    userDir.normalize();
+    Vec2r t(orthDir[1], -orthDir[0]);
+    real dp1 = userDir*orthDir;
+    real dp2 = userDir*t;
+    real h = (thickness[1]+thickness[0])/dp1;
+    real x = fabs(h*dp2/2.0);
+    if(dp1>0){
+      //i'm in the upper part of the unit circle
+      if(dp2>0){
+        //i'm in the upper-right part of the unit circle
+        // i must move vertex 1
+        _vertices[1]->setPoint2d(_vertices[0]->point2d()-userDir*(h));
+        //_vertices[0]->setPoint2d(_vertices[0]->point2d()+t*x);
+        //_vertices[1]->setPoint2d(_vertices[1]->point2d()-t*x);
+      }else{
+        //i'm in the upper-left part of the unit circle
+        // i must move vertex 0
+        _vertices[0]->setPoint2d(_vertices[1]->point2d()+userDir*(h));
+        //_vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
+        //_vertices[1]->setPoint2d(_vertices[1]->point2d()+t*x);
+      }
+    }else{
+      //i'm in the lower part of the unit circle
+      if(dp2>0){
+        //i'm in the lower-right part of the unit circle
+        // i must move vertex 0
+        //_vertices[0]->setPoint2d(_vertices[1]->point2d()-userDir*(h));
+        _vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
+        //_vertices[1]->setPoint2d(_vertices[1]->point2d()+t*x);
+      }else{
+        //i'm in the lower-left part of the unit circle
+        // i must move vertex 1
+        _vertices[1]->setPoint2d(_vertices[0]->point2d()+userDir*(h));
+        //_vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
+        //_vertices[1]->setPoint2d(_vertices[1]->point2d()-t*x);
+      }
+    }
+  }
+  
+  
+  //  Vec2r userDir = _stroke->getBeginningOrientation();
+  //  if(userDir != Vec2r(0,0)){
+  //    userDir.normalize();
+  //    real o1 = (orthDir*userDir);
+  //    real o2 = crossP(orthDir,userDir);
+  //    real orientation = o1 * o2;
+  //    if(orientation > 0){
+  //      // then the vertex to move is v0
+  //      if(o1 > 0)
+  //        _vertex[0]=_vertex[1]+userDir;
+  //      else
+  //        _vertex[0]=_vertex[1]-userDir;
+  //    }
+  //    if(orientation < 0){
+  //      // then we must move v1
+  //      if(o1 < 0)
+  //        _vertex[1]=_vertex[0]+userDir;
+  //      else
+  //        _vertex[1]=_vertex[0]-userDir;
+  //    }
+  //  }
+  
+  int i=2; //2 because we have already processed the first vertex
+
+  for(vend=iStrokeVertices.end();
+  v!=vend;
+  v++){
+      v2=v; ++v2;
+      if (v2==vend) break;
+      sv= (*v); sv2 = (*v2); svPrev=(*vPrev);
+      Vec2r p(sv->getPoint()), p2(sv2->getPoint()), pPrev(svPrev->getPoint());
+			
+      //direction and orthogonal vector to the next segment
+      Vec2r dir(p2-p);
+      float dirNorm=dir.norm();
+      dir.normalize();
+      Vec2r orthDir(-dir[1], dir[0]);
+      Vec2r stripDir = orthDir;
+      if(sv->attribute().isAttributeAvailableVec2f("orientation")){
+        Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
+        userDir.normalize();
+        real dp = userDir*orthDir;
+        if(dp<0)
+          userDir = userDir*(-1.f);
+        stripDir = userDir;
+      } 
+
+      //direction and orthogonal vector to the previous segment
+      Vec2r dirPrev(p-pPrev);
+      float dirPrevNorm=dirPrev.norm();
+      dirPrev.normalize();
+      Vec2r orthDirPrev(-dirPrev[1], dirPrev[0]);
+      Vec2r stripDirPrev = orthDirPrev;
+      if(svPrev->attribute().isAttributeAvailableVec2f("orientation")){
+        Vec2r userDir = svPrev->attribute().getAttributeVec2f("orientation");
+        userDir.normalize();
+        real dp = userDir*orthDir;
+        if(dp<0)
+          userDir = userDir*(-1.f);
+        stripDirPrev = userDir;
+      } 
+
+      const float *thickness =  sv->attribute().getThickness();
+      _averageThickness+=thickness[0]+thickness[1];
+      Vec2r pInter;
+      int interResult;
+
+      interResult=GeomUtils::intersect2dLine2dLine(Vec2r(pPrev+thickness[1]*stripDirPrev), Vec2r(p+thickness[1]*stripDirPrev),
+						   Vec2r(p+thickness[1]*stripDir), Vec2r(p2+thickness[1]*stripDir),
+						   pInter);
+		
+      if (interResult==GeomUtils::DO_INTERSECT) 
+        _vertices.push_back(new StrokeVertexRep(pInter));
+      else 
+        _vertices.push_back(new StrokeVertexRep(p+thickness[1]*stripDir));
+      ++i;
+		
+      interResult=GeomUtils::intersect2dLine2dLine(Vec2r(pPrev-thickness[0]*stripDirPrev), Vec2r(p-thickness[0]*stripDirPrev),
+						   Vec2r(p-thickness[0]*stripDir), Vec2r(p2-thickness[0]*stripDir),
+						   pInter);
+      if (interResult==GeomUtils::DO_INTERSECT) 
+        _vertices.push_back(new StrokeVertexRep(pInter));
+      else 
+        _vertices.push_back(new StrokeVertexRep(p-thickness[0]*stripDir));
+      ++i;
+		
+      // if the angle is obtuse, we simply average the directions to avoid the singularity
+      stripDir=stripDir+stripDirPrev;
+      if ((dirNorm<ZERO) || (dirPrevNorm<ZERO) || (stripDir.norm() < ZERO)) {
+	      stripDir[0] = 0;
+	      stripDir[1] = 0;
+      }else
+	      stripDir.normalize();
+
+      Vec2r vec_tmp(_vertices[i-2]->point2d()-p);
+      if  ((vec_tmp.norm() > thickness[1]*MAX_RATIO_LENGTH_SINGU) || 
+	        (dirNorm<ZERO) || (dirPrevNorm<ZERO) ||
+	        notValid(_vertices[i-2]->point2d()) 
+	        || (fabs(stripDir * dir) < EPS_SINGULARITY_RENDERER))
+	      _vertices[i-2]->setPoint2d(p+thickness[1]*stripDir);
+		
+      vec_tmp = _vertices[i-1]->point2d()-p;
+      if  ((vec_tmp.norm() > thickness[1]*MAX_RATIO_LENGTH_SINGU) ||
+	        (dirNorm<ZERO) || (dirPrevNorm<ZERO) ||
+	        notValid(_vertices[i-1]->point2d())
+	        || (fabs(stripDir * dir)<EPS_SINGULARITY_RENDERER))
+	      _vertices[i-1]->setPoint2d(p-thickness[0]*stripDir);
+
+      vPrev=v;
+  } // end of for
+
+  //special case of last vertex
+  sv=*v;
+  sv2=*vPrev;
+  dir=Vec2r (sv->getPoint()-sv2->getPoint());
+  orthDir=Vec2r(-dir[1], dir[0]);
+  if (orthDir.norm() > ZERO)
+    orthDir.normalize();
+  const float *thicknessLast =  sv->attribute().getThickness();
+  _vertices.push_back(new StrokeVertexRep(sv->getPoint()+thicknessLast[1]*orthDir));
+  ++i;
+  _vertices.push_back(new StrokeVertexRep(sv->getPoint()-thicknessLast[0]*orthDir));
+  int n = i;
+  ++i;
+  
+  // check whether the orientation
+  // was user defined
+  if(sv->attribute().isAttributeAvailableVec2f("orientation")){
+    Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
+    userDir.normalize();
+    Vec2r t(orthDir[1], -orthDir[0]);
+    real dp1 = userDir*orthDir;
+    real dp2 = userDir*t;
+    real h = (thicknessLast[1]+thicknessLast[0])/dp1;
+    //soc unused - real x = fabs(h*dp2/2.0);
+    if(dp1>0){
+      //i'm in the upper part of the unit circle
+      if(dp2>0){
+        //i'm in the upper-right part of the unit circle
+        // i must move vertex n-1
+        _vertices[n-1]->setPoint2d(_vertices[n]->point2d()-userDir*(h));
+        //_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()+t*x);
+        //_vertices[n]->setPoint2d(_vertices[n]->point2d()-t*x);
+      }else{
+        //i'm in the upper-left part of the unit circle
+        // i must move vertex n
+        _vertices[n]->setPoint2d(_vertices[n-1]->point2d()+userDir*(h));
+        //_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()-t*x);
+        //_vertices[n]->setPoint2d(_vertices[n]->point2d()+t*x);
+      }
+    }else{
+      //i'm in the lower part of the unit circle
+      if(dp2>0){
+        //i'm in the lower-right part of the unit circle
+        // i must move vertex n
+        _vertices[n]->setPoint2d(_vertices[n-1]->point2d()-userDir*(h));
+        //_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()-t*x);
+        //_vertices[n]->setPoint2d(_vertices[n]->point2d()+t*x);
+      }else{
+        //i'm in the lower-left part of the unit circle
+        // i must move vertex n-1
+        _vertices[n-1]->setPoint2d(_vertices[n]->point2d()+userDir*(h));
+        //_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()+t*x);
+        //_vertices[n]->setPoint2d(_vertices[n]->point2d()-t*x);
+      }
+    }
+  }
+  
+	
+  // check whether the orientation of the extremity 
+  // was user defined
+  //  userDir = _stroke->getEndingOrientation();
+  //  if(userDir != Vec2r(0,0)){
+  //    userDir.normalize();
+  //    real o1 = (orthDir*userDir);
+  //    real o2 = crossP(orthDir,userDir);
+  //    real orientation = o1 * o2;
+  //    if(orientation > 0){
+  //      // then the vertex to move is vn
+  //      if(o1 < 0)
+  //        _vertex[n]=_vertex[n-1]+userDir;
+  //      else
+  //        _vertex[n]=_vertex[n-1]-userDir;
+  //    }
+  //    if(orientation < 0){
+  //      // then we must move vn-1
+  //      if(o1 > 0)
+  //        _vertex[n-1]=_vertex[n]+userDir;
+  //      else
+  //        _vertex[n-1]=_vertex[n]-userDir;
+  //    }
+  //  }
+
+  _averageThickness/=float(iStrokeVertices.size()-2); 
+  //I did not use the first and last vertex for the average
+  if (iStrokeVertices.size()<3)
+    _averageThickness=0.5*(thicknessLast[1]+thicknessLast[0]+thickness[0]+thickness[1]);
+
+  if (i != 2*(int)iStrokeVertices.size())
+    cerr << "Warning: problem with stripe size\n";
+
+  cleanUpSingularities (iStrokeVertices);
+}	
+
+// CLEAN UP
+/////////////////////////
+
+void
+Strip::cleanUpSingularities (const vector<StrokeVertex*>& iStrokeVertices)
+{
+  int k;
+  int sizeStrip = _vertices.size();
+
+  for (k=0; k<sizeStrip; k++)
+    if (notValid(_vertices[k]->point2d()))
+      {
+	cerr << "Warning: strip vertex " << k << " non valid" << endl;
+	return;
+      }
+
+  //return;
+  if (iStrokeVertices.size()<2) return;
+  int i=0, j;
+  vector<StrokeVertex*>::const_iterator v ,vend, v2, vPrev;
+StrokeVertex *sv, *sv2; //soc unused -  *svPrev;
+	
+  bool singu1=false, singu2=false;
+  int timeSinceSingu1=0, timeSinceSingu2=0;
+
+  //special case of first vertex
+  v=iStrokeVertices.begin();
+  for(vend=iStrokeVertices.end();
+      v!=vend;
+      v++)
+    {
+      v2=v; ++v2;
+      if (v2==vend) break;
+      sv= (*v); sv2 = (*v2); 
+      Vec2r p(sv->getPoint()), p2(sv2->getPoint());
+		
+      Vec2r dir(p2-p);
+      if (dir.norm() > ZERO)
+	dir.normalize();
+      Vec2r dir1, dir2;
+      dir1=_vertices[2*i+2]->point2d()-_vertices[2*i]->point2d();
+      dir2=_vertices[2*i+3]->point2d()-_vertices[2*i+1]->point2d();
+		
+      if ((dir1 * dir) < -ZERO)
+	{
+	  singu1=true;
+	  timeSinceSingu1++;
+	}
+      else
+	{
+	  if (singu1)
+	    {
+	      int toto=i-timeSinceSingu1;
+	      if (toto<0) 
+		cerr << "Stephane dit \"Toto\"" << endl;
+	      //traverse all the vertices of the singularity and average them
+	      Vec2r avP(0.0,0.0);
+	      for (j=i-timeSinceSingu1; j<i+1; j++)
+		avP=Vec2r(avP+_vertices[2*j]->point2d());
+	      avP=Vec2r(1.0/float(timeSinceSingu1+1)*avP);
+	      for (j=i-timeSinceSingu1; j<i+1; j++)
+		_vertices[2*j]->setPoint2d(avP);
+	      //_vertex[2*j]=_vertex[2*i];
+	      singu1=false; timeSinceSingu1=0;
+	    }
+	}
+      if ((dir2 * dir) < -ZERO)
+	{
+	  singu2=true;
+	  timeSinceSingu2++;
+	}
+      else
+	{
+	  if (singu2)
+	    {
+	      int toto=i-timeSinceSingu2;
+	      if (toto<0) 
+		cerr << "Stephane dit \"Toto\"" << endl;
+	      //traverse all the vertices of the singularity and average them
+	      Vec2r avP(0.0,0.0);
+	      for (j=i-timeSinceSingu2; j<i+1; j++)
+		avP=Vec2r(avP+_vertices[2*j+1]->point2d());
+	      avP=Vec2r(1.0/float(timeSinceSingu2+1)*avP);
+	      for (j=i-timeSinceSingu2; j<i+1; j++)
+		_vertices[2*j+1]->setPoint2d(avP);
+	      //_vertex[2*j+1]=_vertex[2*i+1];
+	      singu2=false; timeSinceSingu2=0;
+	    }
+	}	
+      i++;
+    }
+	
+  if (singu1)
+    {
+      //traverse all the vertices of the singularity and average them
+      Vec2r avP(0.0,0.0);
+      for (j=i-timeSinceSingu1; j<i; j++)
+	avP=Vec2r(avP+_vertices[2*j]->point2d());
+      avP=Vec2r(1.0/float(timeSinceSingu1)*avP);
+      for (j=i-timeSinceSingu1; j<i; j++)
+	_vertices[2*j]->setPoint2d(avP);
+    }
+  if (singu2)
+    {
+      //traverse all the vertices of the singularity and average them
+      Vec2r avP(0.0,0.0);
+      for (j=i-timeSinceSingu2; j<i; j++)
+	avP=Vec2r(avP+_vertices[2*j+1]->point2d());
+      avP=Vec2r(1.0/float(timeSinceSingu2)*avP);
+      for (j=i-timeSinceSingu2; j<i; j++)
+	_vertices[2*j+1]->setPoint2d(avP);
+    }
+	
+
+  for (k=0; k<sizeStrip; k++)
+    if (notValid(_vertices[k]->point2d()))
+      {
+	cerr << "Warning: strip vertex " << k << " non valid after cleanup"<<endl;
+	return;
+      }
+}
+
+
+// Texture coordinates
+////////////////////////////////
+
+void
+Strip::computeTexCoord (const vector<StrokeVertex*>& iStrokeVertices)
+{
+  vector<StrokeVertex*>::const_iterator v ,vend;
+  StrokeVertex *sv;
+  int i=0;
+  for(v=iStrokeVertices.begin(), vend=iStrokeVertices.end();
+      v!=vend;	v++)
+    {
+      sv= (*v); 
+      _vertices[i]->setTexCoord(Vec2r((real)(sv->curvilinearAbscissa() / _averageThickness),0));
+      _vertices[i]->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      _vertices[i]->setAlpha(sv->attribute().getAlpha());
+      i++;
+      _vertices[i]->setTexCoord(Vec2r((real)(sv->curvilinearAbscissa() / _averageThickness),1));
+      _vertices[i]->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      _vertices[i]->setAlpha(sv->attribute().getAlpha());
+      i++;
+      //		cerr<<"col=("<<sv->attribute().getColor()[0]<<", "
+      //			<<sv->attribute().getColor()[1]<<", "<<sv->attribute().getColor()[2]<<")"<<endl;
+    }
+}
+
+void
+Strip::computeTexCoordWithTips (const vector<StrokeVertex*>& iStrokeVertices, bool tipBegin, bool tipEnd)
+{
+  //soc unused - unsigned int sizeStrip = _vertices.size()+8; //for the transition between the tip and the body
+  vector<StrokeVertex*>::const_iterator v ,vend;
+  StrokeVertex *sv = 0;
+
+  v=iStrokeVertices.begin();
+  vend=iStrokeVertices.end();
+  float l=(*v)->strokeLength()/_averageThickness;
+  int tiles=int(l);
+  float fact=(float(tiles)+0.5)/l;
+  //soc unused - float uTip2=float(tiles)+0.25;
+  float u=0; 
+  float uPrev=0;
+  int i=0;
+  float t;
+  StrokeVertexRep *tvRep1, *tvRep2;
+
+  //		cerr<<"l="<<l<<"  tiles="<<tiles<<"    _averageThicnkess="
+  //			<<_averageThickness<<"    strokeLength="<<(*v)->strokeLength()<<endl;
+  //
+  vector<StrokeVertexRep*>::iterator currentSV = _vertices.begin();
+  StrokeVertexRep *svRep;
+  if(tipBegin){
+  for(;v!=vend; v++)
+    {
+      sv= (*v); 
+      svRep = *currentSV;
+      u=sv->curvilinearAbscissa()/_averageThickness*fact;
+      if (u>0.25) break;
+
+      
+      svRep->setTexCoord(Vec2r((real)u, 0.5));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+      
+      svRep = *currentSV;
+      svRep->setTexCoord(Vec2r((real)u, 1));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+      uPrev=u;
+    }
+  //first transition vertex
+  
+  if (fabs(u-uPrev)>ZERO)
+    t= (0.25-uPrev)/(u-uPrev);
+  else t=0;
+  //if (!tiles) t=0.5;
+  tvRep1 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
+  tvRep1->setTexCoord(Vec2r(0.25,0.5));
+  tvRep1->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
+		  t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
+  tvRep1->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
+  i++;
+  
+  tvRep2 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
+  tvRep2->setTexCoord(Vec2r(0.25,1));
+  tvRep2->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
+		  t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
+  tvRep2->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
+  i++;
+
+  currentSV = _vertices.insert(currentSV, tvRep1);
+  ++currentSV;
+  currentSV = _vertices.insert(currentSV, tvRep2);
+  ++currentSV;
+
+  //copy the vertices with different texture coordinates
+  tvRep1 = new StrokeVertexRep(_vertices[i-2]->point2d());
+  tvRep1->setTexCoord(Vec2r(0.25,0));
+  tvRep1->setColor(_vertices[i-2]->color());
+  tvRep1->setAlpha(_vertices[i-2]->alpha());
+  i++;
+
+  tvRep2 = new StrokeVertexRep(_vertices[i-2]->point2d());
+  tvRep2->setTexCoord(Vec2r(0.25,0.5));
+  tvRep2->setColor(_vertices[i-2]->color());
+  tvRep2->setAlpha(_vertices[i-2]->alpha());
+  i++;
+  
+  currentSV = _vertices.insert(currentSV, tvRep1);
+  ++currentSV;
+  currentSV = _vertices.insert(currentSV, tvRep2);
+  ++currentSV;
+  }
+  uPrev=0;
+
+  //body of the stroke
+  for(;v!=vend; v++)
+    {
+      sv= (*v); 
+      svRep = *currentSV;
+      u=sv->curvilinearAbscissa()/_averageThickness*fact-0.25;
+      if (u>tiles) break;
+
+      svRep->setTexCoord(Vec2r((real)u, 0));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+
+      svRep = *currentSV;
+      svRep->setTexCoord(Vec2r((real)u, 0.5));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+      
+      uPrev=u;
+    }
+  if(tipEnd){
+  //second transition vertex
+  if ((fabs(u-uPrev)>ZERO))
+    t= (float(tiles)-uPrev)/(u-uPrev);
+  else t=0;
+
+  tvRep1 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
+  tvRep1->setTexCoord(Vec2r((real)tiles,0));
+  tvRep1->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
+		  t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
+  tvRep1->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
+  i++;
+  
+  tvRep2 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
+  tvRep2->setTexCoord(Vec2r((real)tiles,0.5));
+  tvRep2->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
+		  t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
+  tvRep2->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
+  i++;
+
+  currentSV = _vertices.insert(currentSV, tvRep1);
+  ++currentSV;
+  currentSV = _vertices.insert(currentSV, tvRep2);
+  ++currentSV;
+
+  //copy the vertices with different texture coordinates
+  tvRep1 = new StrokeVertexRep(_vertices[i-2]->point2d());
+  tvRep1->setTexCoord(Vec2r(0.75,0.5));
+  tvRep1->setColor(_vertices[i-2]->color());
+  tvRep1->setAlpha(_vertices[i-2]->alpha());
+  i++;
+
+  tvRep2 = new StrokeVertexRep(_vertices[i-2]->point2d());
+  tvRep2->setTexCoord(Vec2r(0.75,1));
+  tvRep2->setColor(_vertices[i-2]->color());
+  tvRep2->setAlpha(_vertices[i-2]->alpha());
+  i++;
+  
+  currentSV = _vertices.insert(currentSV, tvRep1);
+  ++currentSV;
+  currentSV = _vertices.insert(currentSV, tvRep2);
+  ++currentSV;
+
+  //end tip
+  for(;v!=vend; v++)
+    {
+      sv= (*v); 
+      svRep = *currentSV;
+      u=0.75+sv->curvilinearAbscissa()/_averageThickness*fact-float(tiles)-0.25;
+      
+      svRep->setTexCoord(Vec2r((real)u, 0.5));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+      
+      svRep = *currentSV;
+      svRep->setTexCoord(Vec2r((real)u, 1));
+      svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
+      svRep->setAlpha(sv->attribute().getAlpha());
+      i++;
+      ++currentSV;
+    }
+  }
+  //cerr<<"u="<<u<<"    i="<<i<<"/"<<_sizeStrip<<endl;;
+
+  //  for (i=0; i<_sizeStrip; i++)
+  //    _alpha[i]=1.0;
+
+  //	for (i=0; i<_sizeStrip; i++)
+  //			cerr<<"("<<_texCoord[i][0]<<", "<<_texCoord[i][1]<<") ";
+  //	cerr<<endl;
+
+  
+  //  Vec2r vec_tmp;
+  //  for (i=0; i<_sizeStrip/2; i++)
+  //    vec_tmp = _vertex[2*i] - _vertex[2*i+1];
+  //    if (vec_tmp.norm() > 4*_averageThickness)
+  //      cerr << "Warning (from Fredo): There is a pb in the texture coordinates computation" << endl;
+}
+
+//
+// StrokeRep
+/////////////////////////////////////
+
+StrokeRep::StrokeRep()
+{
+  _stroke = 0;
+  _strokeType=Stroke::OPAQUE_MEDIUM;
+  TextureManager * ptm = TextureManager::getInstance();
+  if(ptm)
+    _textureId = ptm->getDefaultTextureId();
+  // _averageTextureAlpha=0.5; //default value
+  // if (_strokeType==OIL_STROKE)
+    // _averageTextureAlpha=0.75; 
+  // if (_strokeType>=NO_BLEND_STROKE)
+    // _averageTextureAlpha=1.0
+} 
+
+StrokeRep::StrokeRep(Stroke *iStroke)
+{
+  _stroke = iStroke;
+  _strokeType = iStroke->getMediumType();
+  _textureId = iStroke->getTextureId();
+  if(_textureId == 0){
+    TextureManager * ptm = TextureManager::getInstance();
+    if(ptm)
+      _textureId = ptm->getDefaultTextureId();
+  }
+    
+  // _averageTextureAlpha=0.5; //default value
+  // if (_strokeType==OIL_STROKE)
+    // _averageTextureAlpha=0.75; 
+  // if (_strokeType>=NO_BLEND_STROKE)
+    // _averageTextureAlpha=1.0;
+  create();
+}
+
+StrokeRep::StrokeRep(const StrokeRep& iBrother)
+{
+  //soc unused - int i=0;
+  _stroke = iBrother._stroke;
+  _strokeType=iBrother._strokeType;
+  _textureId = iBrother._textureId;
+  for(vector<Strip*>::const_iterator s=iBrother._strips.begin(), send=iBrother._strips.end();
+  s!=send;
+  ++s){
+    _strips.push_back(new Strip(**s));
+  }
+}
+
+
+StrokeRep::~StrokeRep()
+{
+  if(!_strips.empty()){
+    for(vector<Strip*>::iterator s=_strips.begin(), send=_strips.end();
+    s!=send;
+    ++s){
+      delete (*s);
+    }
+    _strips.clear();
+  }
+}
+
+void StrokeRep::create(){
+  vector<StrokeVertex*> strip;
+  StrokeInternal::StrokeVertexIterator v = _stroke->strokeVerticesBegin();
+  StrokeInternal::StrokeVertexIterator vend = _stroke->strokeVerticesEnd();
+  
+  bool first=true;
+  bool end=false;
+  while(v!=vend){
+    while((v!=vend) && (!(*v).attribute().isVisible())){
+      ++v;
+      first = false;
+    }
+    while( (v!=vend) && ((*v).attribute().isVisible()) ) {
+      strip.push_back(&(*v));
+      ++v;
+    }
+    if(v!=vend){
+      // add the last vertex and create
+      strip.push_back(&(*v));
+    }else{
+      end=true;
+    }
+    if((!strip.empty()) && (strip.size()>1) ){
+      _strips.push_back(new Strip(strip, _stroke->hasTips(), first, end));
+      strip.clear();
+    }
+    first = false;
+  }
+} 
+
+void StrokeRep::Render(const StrokeRenderer *iRenderer)
+{
+  iRenderer->RenderStrokeRep(this);
+}
+
+
+
diff --git a/source/blender/freestyle/intern/stroke/StrokeRep.h b/source/blender/freestyle/intern/stroke/StrokeRep.h
new file mode 100755
index 00000000000..d8a8dc2d609
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeRep.h
@@ -0,0 +1,138 @@
+//
+//  Filename         : StrokeRep.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the representation of a stroke
+//                     (for display purpose)
+//  Date of creation : 05/03/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKEREP_H
+# define STROKEREP_H
+
+# include "../geometry/Geom.h"
+using namespace Geometry;
+
+//symbolic constant to call the appropriate renderers and textures
+// # define NO_TEXTURE_WITH_BLEND_STROKE	-2
+// # define NO_TEXTURE_STROKE		-1
+// # define PSEUDO_CHARCOAL_STROKE		0
+// # define WASH_BRUSH_STROKE		1
+// # define OIL_STROKE			2
+// # define NO_BLEND_STROKE		3
+// # define CHARCOAL_MIN_STROKE		4
+// # define BRUSH_MIN_STROKE		5
+// # define OPAQUE_DRY_STROKE		6
+// # define OPAQUE_STROKE			7
+// 
+// # define DEFAULT_STROKE			0
+// 
+// # define NUMBER_STROKE_RENDERER		8
+
+#include "Stroke.h"
+
+class StrokeVertexRep{
+public:
+  StrokeVertexRep(){}
+  StrokeVertexRep(const Vec2r& iPoint2d){_point2d=iPoint2d;}
+  StrokeVertexRep(const StrokeVertexRep& iBrother);
+  virtual ~StrokeVertexRep(){}
+
+  inline Vec2r& point2d() {return _point2d;}
+  inline Vec2r& texCoord() {return _texCoord;}
+  inline Vec3r& color() {return _color;}
+  inline float alpha() {return _alpha;}
+
+  inline void setPoint2d(const Vec2r& p){_point2d = p;}
+  inline void setTexCoord(const Vec2r& p){_texCoord = p;}
+  inline void setColor(const Vec3r& p){_color = p;}
+  inline void setAlpha(float a){_alpha = a;}
+protected:
+  Vec2r _point2d;
+  Vec2r _texCoord;
+  Vec3r _color;
+  float _alpha;
+};
+
+class Strip{
+public: 
+  typedef std::vector<StrokeVertexRep*> vertex_container;
+protected:
+  vertex_container _vertices;
+  float _averageThickness;
+
+
+public:
+  Strip(const std::vector<StrokeVertex*>& iStrokeVertices, bool hasTips=false, bool tipBegin=false, bool tipEnd=false) ;
+  Strip(const Strip& iBrother);
+  virtual ~Strip() ;
+
+protected:
+  void createStrip(const std::vector<StrokeVertex*>& iStrokeVertices);
+  void cleanUpSingularities(const std::vector<StrokeVertex*>& iStrokeVertices);
+  void computeTexCoord (const std::vector<StrokeVertex*>& iStrokeVertices);
+  void computeTexCoordWithTips (const std::vector<StrokeVertex*>& iStrokeVertices, bool tipBegin, bool tipEnd);
+public:
+  inline int sizeStrip() const {return _vertices.size();}
+  inline vertex_container& vertices() {return _vertices;}
+};
+
+class StrokeRep
+{
+protected:
+  Stroke *_stroke;
+  vector<Strip*> _strips;
+  Stroke::MediumType _strokeType;
+  unsigned int _textureId;
+
+  // float _averageTextureAlpha;
+  
+
+public:
+  StrokeRep();
+  StrokeRep(const StrokeRep&);
+  StrokeRep(Stroke *iStroke);
+  virtual ~StrokeRep();
+
+  /*! Creates the strips */
+  virtual void create() ;
+  
+  /*! Renders the stroke using a Renderer */
+  virtual void Render(const StrokeRenderer *iRenderer) ;
+
+  /*! accessors */
+  inline Stroke::MediumType getMediumType() const {return _strokeType;}
+  inline unsigned getTextureId() const {return _textureId;}
+  inline vector<Strip*>& getStrips() {return _strips;}
+  inline unsigned int getNumberOfStrips() const {return _strips.size();}
+  inline Stroke * getStroke() {return _stroke;}
+ 
+  /*! modifiers */
+  inline void setMediumType(Stroke::MediumType itype) {_strokeType=itype;}
+  inline void setTextureId(unsigned textureId) {_textureId = textureId;}
+
+  
+};
+
+#endif // STROKEREP_H
diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h
new file mode 100755
index 00000000000..fa1289f6e0f
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeShader.h
@@ -0,0 +1,119 @@
+//
+//  Filename         : StrokeShader.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class defining StrokeShader
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SHADERS_H
+# define SHADERS_H
+
+# include <iostream>
+# include <vector>
+
+//
+//  StrokeShader base class
+//
+//////////////////////////////////////////////////////
+
+class Stroke;
+/*! Base class for Stroke Shaders.
+ *  Any Stroke Shader must inherit from
+ *  this class and overload the shade() method.
+ *  A StrokeShader is designed to modify any
+ *  Stroke's attribute such as Thickness, Color,
+ *  Geometry, Texture, Blending mode...
+ *  The basic way to achieve this operation consists
+ *  in iterating over the StrokeVertices of the Stroke
+ *  and to modify each one's StrokeAttribute.
+ *  Here is a python code example of such an iteration:
+ *  \code
+ *  it = ioStroke.strokeVerticesBegin()
+ *  while it.isEnd() == 0:
+ *      att = it.getObject().attribute()
+ *      ## perform here any attribute modification
+ *      it.increment()
+ *  \endcode
+ *  Here is a C++ code example of such an iteration:
+ *  \code
+ *  for(StrokeInternal::StrokeVertexIterator v=ioStroke.strokeVerticesBegin(), vend=ioStroke.strokeVerticesEnd();
+ *	v!=vend;
+ *	++v){
+ *    StrokeAttribute& att = v->attribute();
+ *    // perform any attribute modification here...
+ *  }
+ *  \endcode
+ */
+class LIB_STROKE_EXPORT StrokeShader
+{
+public:
+  /*! Default constructor. */
+  StrokeShader() {}
+  /*! Destructor. */
+  virtual ~StrokeShader() {}
+  /*! Returns the string corresponding to the
+   *  shader's name.
+   */
+  virtual string getName() const {
+    return "StrokeShader";
+  }
+  /*! The shading method. This method must
+   *  be overloaded by inherited classes.
+   *  The shading method is designed to modify any
+   *  Stroke's attribute such as Thickness, Color,
+   *  Geometry, Texture, Blending mode...
+   *  The basic way to achieve this operation consists
+   *  in iterating over the StrokeVertices of the Stroke
+   *  and to modify each one's StrokeAttribute.
+   *  Here is a python code example of such an iteration:
+   *  \code
+   *  it = ioStroke.strokeVerticesBegin()
+   *  while it.isEnd() == 0:
+   *      att = it.getObject().attribute()
+   *      ## perform here any attribute modification
+   *      it.increment()
+   *  \endcode
+   *  Here is a C++ code example of such an iteration:
+   *  \code
+   *  for(StrokeInternal::StrokeVertexIterator v=ioStroke.strokeVerticesBegin(), vend=ioStroke.strokeVerticesEnd();
+   *	v!=vend;
+   *	++v){
+   *    StrokeAttribute& att = v->attribute();
+   *    // perform any attribute modification here...
+   *  }
+   *  \endcode
+   *  \param ioStroke
+   *    The stroke we wish to shade. this Stroke
+   *    is modified by the Shader (which typically
+   *    modifies the Stroke's attribute's values such
+   *    as Color, Thickness, Geometry...)
+   */
+  virtual void shade(Stroke& ioStroke) const {
+    cerr << "Warning: method shade() not implemented" << endl;
+  }
+
+};
+
+# endif // SHADERS_H
diff --git a/source/blender/freestyle/intern/stroke/StrokeTesselator.cpp b/source/blender/freestyle/intern/stroke/StrokeTesselator.cpp
new file mode 100755
index 00000000000..279655c22b7
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeTesselator.cpp
@@ -0,0 +1,88 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../scene_graph/OrientedLineRep.h"
+#include "../scene_graph/NodeGroup.h"
+#include "../scene_graph/NodeShape.h"
+#include "StrokeTesselator.h"
+#include "StrokeAdvancedIterators.h"
+
+LineRep* StrokeTesselator::Tesselate(Stroke *iStroke)
+{
+  if(0 == iStroke)
+    return 0;
+
+  LineRep* line;
+  line = new OrientedLineRep();
+  
+  Stroke::vertex_iterator v,vend;
+  if(2 == iStroke->vertices_size())
+  {
+    line->setStyle(LineRep::LINES);
+    v = iStroke->vertices_begin();
+    StrokeVertex *svA= (*v);
+    v++;
+    StrokeVertex *svB = (*v);
+    Vec3r A((*svA)[0], (*svA)[1], 0);
+    Vec3r B((*svB)[0], (*svB)[1], 0);
+    line->AddVertex(A);
+    line->AddVertex(B);
+  }
+  else
+  {
+    if(_overloadMaterial)
+      line->setMaterial(_Material);
+
+    line->setStyle(LineRep::LINE_STRIP);
+
+    for(v=iStroke->vertices_begin(), vend=iStroke->vertices_end();
+    v!=vend;
+    v++)
+    {
+      StrokeVertex *sv= (*v);
+      Vec3r V((*sv)[0], (*sv)[1], 0);
+      line->AddVertex(V);         
+    } 
+  }
+  line->setId(iStroke->getId());
+  line->ComputeBBox();
+
+  return line;
+}
+
+template<class StrokeVertexIterator>
+NodeGroup* StrokeTesselator::Tesselate(StrokeVertexIterator begin, StrokeVertexIterator end) 
+{
+  NodeGroup *group = new NodeGroup;
+  NodeShape *tshape = new NodeShape;
+  group->AddChild(tshape);
+  //tshape->material().setDiffuse(0.f, 0.f, 0.f, 1.f);
+  tshape->setMaterial(_Material);
+
+  for(StrokeVertexIterator c=begin, cend=end;
+  c!=cend;
+  c++)
+  {  
+      tshape->AddRep(Tesselate((*c)));
+  }
+  
+  return group;
+}
diff --git a/source/blender/freestyle/intern/stroke/StrokeTesselator.h b/source/blender/freestyle/intern/stroke/StrokeTesselator.h
new file mode 100755
index 00000000000..eaeb73504c9
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StrokeTesselator.h
@@ -0,0 +1,67 @@
+//
+//  Filename         : StrokeTesselator.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to build a Node Tree designed to be displayed 
+//                     from a set of strokes structure.
+//  Date of creation : 26/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STROKETESSELATOR_H
+# define STROKETESSELATOR_H
+
+# include "../scene_graph/LineRep.h"
+# include "Stroke.h"
+
+class StrokeTesselator
+{
+public:
+
+  inline StrokeTesselator() {_Material.setDiffuse(0,0,0,1);_overloadMaterial=false;}
+  virtual ~StrokeTesselator() {}
+
+  /*! Builds a line rep contained from a Stroke
+   */
+  LineRep* Tesselate(Stroke* iStroke) ;
+
+  /*! Builds a set of lines rep contained under a 
+   *  a NodeShape, itself contained under a NodeGroup from a 
+   *  set of strokes
+   */
+  template<class StrokeIterator>
+  NodeGroup* Tesselate(StrokeIterator begin, StrokeIterator end) ;
+
+  
+  
+  inline void setMaterial(const Material& iMaterial) {_Material=iMaterial;_overloadMaterial=true;}
+  inline const Material& material() const {return _Material;}
+
+private:
+
+  Material _Material;
+  bool _overloadMaterial;
+};
+
+#endif // STROKETESSELATOR_H
+
diff --git a/source/blender/freestyle/intern/stroke/StyleModule.h b/source/blender/freestyle/intern/stroke/StyleModule.h
new file mode 100755
index 00000000000..3d39e53515b
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/StyleModule.h
@@ -0,0 +1,144 @@
+//
+//  Filename         : StyleModule.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Class representing a style module
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STYLE_MODULE_H
+# define STYLE_MODULE_H
+
+# include <iostream>
+# include <string>
+# include "../system/StringUtils.h"
+# include "StrokeLayer.h"
+# include "../system/Interpreter.h"
+# include "Operators.h"
+# include "StrokeShader.h"
+
+using namespace std;
+
+class StyleModule
+{
+public:
+
+  StyleModule(const string& file_name,
+	      Interpreter* inter) : _file_name(file_name) {
+    _always_refresh = false;
+    _causal = false;
+    _drawable = true;
+    _modified = true;
+    _displayed = true;
+    _inter = inter;
+  }
+
+  ~StyleModule() {}
+
+  StrokeLayer* execute() {
+    if (!_inter) {
+      cerr << "Error: no interpreter was found to execute the script" << endl;
+      return NULL;
+    }
+    Operators::reset();
+    if (_inter->interpretFile(_file_name))
+      return NULL;
+    Operators::StrokesContainer* strokes_set = Operators::getStrokesSet();
+    if (!_drawable || strokes_set->empty())
+      return NULL;
+    StrokeLayer* sl = new StrokeLayer;
+    for (Operators::StrokesContainer::iterator it = strokes_set->begin();
+	 it != strokes_set->end();
+	 ++it)
+      sl->AddStroke(*it);
+
+   return sl;
+  }
+
+  // accessors
+
+  const string getFileName() const {
+    return _file_name;
+  }
+
+  bool getAlwaysRefresh() const {
+    return _always_refresh;
+  }
+
+  bool getCausal() const {
+    return _causal;
+  }
+
+  bool getDrawable() const {
+    return _drawable;
+  }
+
+  bool getModified() const {
+    return _modified;
+  }
+
+ bool getDisplayed() const {
+    return _displayed;
+  }
+
+  // modifiers
+
+  void setFileName(const string& file_name) {
+    _file_name = file_name;
+  }
+
+  void setAlwaysRefresh(bool b = true) {
+    _always_refresh = b;
+  }
+
+  void setCausal(bool b = true) {
+    _causal = b;
+  }
+
+  void setDrawable(bool b = true) {
+    _drawable = b;
+  }
+
+  void setModified(bool b = true) {
+    if (_always_refresh)
+      return;
+    _modified = b;
+  }
+
+  void setDisplayed(bool b = true) {
+    _displayed = b;
+  }
+
+private:
+
+  string	_file_name;
+  bool		_always_refresh;
+  bool		_causal;
+  bool		_drawable;
+  bool		_modified;
+  bool		_displayed;
+  Interpreter*	_inter;
+};
+
+#endif // STYLE_MODULE_H
diff --git a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.cpp b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.cpp
new file mode 100755
index 00000000000..ea5af287bbe
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.cpp
@@ -0,0 +1,73 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "TextStrokeRenderer.h"
+# include "Canvas.h"
+# include "StrokeIterators.h"
+
+TextStrokeRenderer::TextStrokeRenderer(const char* iFileName)
+:StrokeRenderer(){
+  if(!iFileName)
+    iFileName = "freestyle.txt";
+  // open the stream:
+  _ofstream.open(iFileName, ios::out);
+  if(!_ofstream.is_open()){
+    cerr << "couldn't open the output file " << iFileName << endl;
+  }
+  _ofstream << "%!FREESTYLE" << endl;
+  _ofstream << "%Creator: Freestyle (http://artis.imag.fr/Software/Freestyle)" << endl;
+  // Bounding box
+  _ofstream << 0 << " "<< 0 << " " << Canvas::getInstance()->width() << " " << Canvas::getInstance()->height() << endl;
+  _ofstream << "%u x y z tleft tright r g b ..." << endl;
+}
+
+TextStrokeRenderer::~TextStrokeRenderer(){
+  Close();
+}
+
+void TextStrokeRenderer::RenderStrokeRep(StrokeRep *iStrokeRep) const{
+  RenderStrokeRepBasic(iStrokeRep);
+}
+
+void TextStrokeRenderer::RenderStrokeRepBasic(StrokeRep *iStrokeRep) const{
+  Stroke *stroke = iStrokeRep->getStroke();
+  if(!stroke){
+    cerr << "no stroke associated with Rep" << endl;
+    return;
+  }
+    
+  StrokeInternal::StrokeVertexIterator v = stroke->strokeVerticesBegin();
+  StrokeAttribute att;
+  while(!v.isEnd()){
+    att = v->attribute();
+    _ofstream << v->u() << " " << v->getProjectedX() << " " << v->getProjectedY() << " " << v->getProjectedZ() << " " \
+      << att.getThicknessL() << " " << att.getThicknessR() << " " \
+      << att.getColorR() << " " << att.getColorG() << " " << att.getColorB() << " ";
+    ++v;
+  }
+  _ofstream << endl;
+}
+
+void TextStrokeRenderer::Close(){
+  if(_ofstream.is_open())
+    _ofstream.close();
+}
+
diff --git a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
new file mode 100755
index 00000000000..ef610d63bdd
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h
@@ -0,0 +1,68 @@
+//
+//  Filename         : TextStrokeRenderer.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to define the text rendering of a stroke
+//                     Format:
+//                     x y width height // bbox
+//                     //list of vertices : 
+//                     t x y z t1 t2 r g b alpha ...
+//                      ...
+//  Date of creation : 01/14/2005
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  TEXTSTROKERENDERER_H
+# define TEXTSTROKERENDERER_H
+
+# include "../system/FreestyleConfig.h"
+# include "StrokeRenderer.h"
+# include <fstream>
+
+/**********************************/
+/*                                */
+/*                                */
+/*         TextStrokeRenderer       */
+/*                                */
+/*                                */
+/**********************************/
+
+class LIB_STROKE_EXPORT TextStrokeRenderer : public StrokeRenderer
+{
+public:
+  TextStrokeRenderer(const char * iFileName = 0);
+  virtual ~TextStrokeRenderer();
+
+  /*! Renders a stroke rep */
+  virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const;
+  virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const;
+
+  /*! Closes the output file */
+  void Close();
+
+protected:
+  mutable ofstream _ofstream;
+};
+
+#endif // TEXTSTROKERENDERER_H
+
diff --git a/source/blender/freestyle/intern/stroke/src.pri b/source/blender/freestyle/intern/stroke/src.pri
new file mode 100755
index 00000000000..09707f86dbc
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/src.pri
@@ -0,0 +1,54 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+STROKE_DIR = ../stroke
+
+SOURCES *= $${STROKE_DIR}/AdvancedFunctions0D.cpp \
+           $${STROKE_DIR}/AdvancedFunctions1D.cpp \
+           $${STROKE_DIR}/AdvancedStrokeShaders.cpp \
+           $${STROKE_DIR}/BasicStrokeShaders.cpp \
+           $${STROKE_DIR}/Canvas.cpp \
+	   $${STROKE_DIR}/Chain.cpp \
+           $${STROKE_DIR}/ChainingIterators.cpp \
+           $${STROKE_DIR}/ContextFunctions.cpp \
+           $${STROKE_DIR}/Operators.cpp \
+           $${STROKE_DIR}/PSStrokeRenderer.cpp \
+	   $${STROKE_DIR}/Stroke.cpp \
+	   $${STROKE_DIR}/StrokeIO.cpp \			       
+	   $${STROKE_DIR}/StrokeLayer.cpp \		       
+	   $${STROKE_DIR}/StrokeRenderer.cpp \		       
+	   $${STROKE_DIR}/StrokeRep.cpp \
+	   $${STROKE_DIR}/StrokeTesselator.cpp \
+	   $${STROKE_DIR}/TextStrokeRenderer.cpp \
+           $${STROKE_DIR}/Curve.cpp 
+
+HEADERS *= $${STROKE_DIR}/AdvancedFunctions0D.h \
+           $${STROKE_DIR}/AdvancedFunctions1D.h \
+           $${STROKE_DIR}/AdvancedPredicates1D.h \
+           $${STROKE_DIR}/AdvancedStrokeShaders.h \
+           $${STROKE_DIR}/BasicStrokeShaders.h \
+	   $${STROKE_DIR}/Canvas.h \			       
+	   $${STROKE_DIR}/Chain.h \			       
+	   $${STROKE_DIR}/ChainingIterators.h \
+           $${STROKE_DIR}/ContextFunctions.h \
+	   $${STROKE_DIR}/Curve.h \
+           $${STROKE_DIR}/CurveIterators.h \
+           $${STROKE_DIR}/CurveAdvancedIterators.h \
+           $${STROKE_DIR}/Module.h \
+           $${STROKE_DIR}/Operators.h \
+	   $${STROKE_DIR}/Predicates1D.h \
+           $${STROKE_DIR}/Predicates0D.h \
+           $${STROKE_DIR}/PSStrokeRenderer.h \
+	   $${STROKE_DIR}/Stroke.h \
+	   $${STROKE_DIR}/StrokeIO.h \			       
+           $${STROKE_DIR}/StrokeIterators.h \
+           $${STROKE_DIR}/StrokeAdvancedIterators.h \
+	   $${STROKE_DIR}/StrokeShader.h \			       
+	   $${STROKE_DIR}/StrokeLayer.h \		       
+	   $${STROKE_DIR}/StrokeRenderer.h \		       
+	   $${STROKE_DIR}/StrokeRep.h \ 
+	   $${STROKE_DIR}/StrokeTesselator.h \
+	   $${STROKE_DIR}/StyleModule.h \
+	   $${STROKE_DIR}/TextStrokeRenderer.h
diff --git a/source/blender/freestyle/intern/stroke/stroke.pro b/source/blender/freestyle/intern/stroke/stroke.pro
new file mode 100755
index 00000000000..90c0cc96592
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/stroke.pro
@@ -0,0 +1,89 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_STROKE}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES           *= MAKE_LIB_STROKE_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../geometry ../image ../system ../view_map \
+#                   ../winged_edge ../scene_graph
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# LIBS
+#
+#######################################
+
+win32:LIBS              *= $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+                           $${DESTDIR}/$${LIB_IMAGE}$${LIBVERSION}.lib \
+                           $${DESTDIR}/$${LIB_SCENE_GRAPH}$${LIBVERSION}.lib \
+                           $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib \
+                           $${DESTDIR}/$${LIB_WINGED_EDGE}$${LIBVERSION}.lib \
+                           $${DESTDIR}/$${LIB_VIEW_MAP}$${LIBVERSION}.lib
+
+!win32 {
+  lib_bundle {
+    LIBS += -F$${DESTDIR} -framework $${LIB_GEOMETRY} -framework $${LIB_IMAGE} -framework $${LIB_SCENE_GRAPH} -framework $${LIB_SYSTEM} -framework $${LIB_WINGED_EDGE} -framework $${LIB_VIEW_MAP}
+  } else {
+    LIBS *= -L$${DESTDIR} -l$${LIB_GEOMETRY} -l$${LIB_IMAGE} -l$${LIB_SCENE_GRAPH} \
+                   -l$${LIB_SYSTEM} -l$${LIB_WINGED_EDGE} -l$${LIB_VIEW_MAP}
+  }
+}
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/intern/swig/Freestyle.i b/source/blender/freestyle/intern/swig/Freestyle.i
new file mode 100755
index 00000000000..37daddc4e11
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Freestyle.i
@@ -0,0 +1,283 @@
+//
+//  FileName         : Freestyle.i
+//  Author           : Emmanuel Turquin
+//  Purpose          : SWIG file used to generate Python binding
+//  Date Of Creation : 18/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+
+%module(directors="1") Freestyle
+%{
+ #include "../system/Cast.h"
+ #include "../stroke/Module.h"
+ #include "../system/Precision.h"
+ #include "../system/Id.h"
+ #include "../geometry/VecMat.h"
+ #include "../geometry/Geom.h"
+ #include "../geometry/Noise.h"
+ #include "../scene_graph/Material.h"
+ #include "../winged_edge/Nature.h"
+ #include "../view_map/Interface0D.h"
+ #include "../view_map/Interface1D.h"
+ #include "../view_map/Functions0D.h"
+ #include "../view_map/Functions1D.h"
+ #include "../view_map/Silhouette.h"
+ #include "../view_map/ViewMap.h"
+ #include "../view_map/ViewMapIterators.h"
+ #include "../stroke/AdvancedFunctions0D.h"
+ #include "../stroke/AdvancedFunctions1D.h"
+ #include "../stroke/ChainingIterators.h"
+ #include "../stroke/ContextFunctions.h"
+ #include "../stroke/Predicates0D.h"
+ #include "../stroke/Predicates1D.h"
+ #include "../stroke/AdvancedPredicates1D.h"
+ #include "../stroke/StrokeShader.h"
+// #include "../stroke/Curve.h"
+ #include "../stroke/CurveIterators.h"       
+ #include "../stroke/Stroke.h"
+ #include "../stroke/StrokeIterators.h"
+ #include "../stroke/BasicStrokeShaders.h"
+ #include "../stroke/AdvancedStrokeShaders.h"
+ #include "../stroke/Operators.h"
+ #include "../stroke/Canvas.h"
+%}
+
+%include "stl.i"
+%template(vectorInt)   std::vector<int>;
+
+#ifdef SWIG
+# define LIB_GEOMETRY_EXPORT
+# define LIB_VIEW_MAP_EXPORT
+# define LIB_STROKE_EXPORT
+# define LIB_GEOMETRY_EXPORT
+#endif // SWIG
+
+// Generic exception handler
+%exception {
+    try {
+        $action
+    }
+//    catch (Swig::DirectorTypeMismatch&) {
+//      cout << "Warning: return type mismatch" << endl;
+//    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+}
+
+// Precision
+%include "../system/Precision.h"
+
+// Id
+%include "../system/Id.h"
+
+// Vec
+%include "../geometry/VecMat.h"
+
+%template(Vec_2u)   VecMat::Vec<unsigned,2>;
+%template(Vec_2i)   VecMat::Vec<int,2>;
+%template(Vec_2d)   VecMat::Vec<double,2>;
+%template(Vec_2f)   VecMat::Vec<float,2>;
+
+%template(Vec2u)	VecMat::Vec2<unsigned>;
+%template(Vec2i)	VecMat::Vec2<int>;
+%template(Vec2f)	VecMat::Vec2<float>;
+%template(Vec2d)	VecMat::Vec2<double>;
+
+%template(Vec_3u)   VecMat::Vec<unsigned,3>;
+%template(Vec_3i)   VecMat::Vec<int,3>;
+%template(Vec_3d)   VecMat::Vec<double,3>;
+%template(Vec_3f)   VecMat::Vec<float,3>;
+
+%template(Vec3u)	VecMat::Vec3<unsigned>;
+%template(Vec3i)	VecMat::Vec3<int>;
+%template(Vec3f)	VecMat::Vec3<float>;
+%template(Vec3d)	VecMat::Vec3<double>;
+
+//%template(HVec3u) VecMat::HVec3<unsigned>;
+//%template(HVec3i) VecMat::HVec3<int>;
+//%template(HVec3f) VecMat::HVec3<float>;
+//%template(HVec3d) VecMat::HVec3<double>;
+//%template(HVec3r) VecMat::HVec3<real>;
+
+//%template(Matrix22u) VecMat::SquareMatrix<unsigned, 2>;
+//%template(Matrix22i) VecMat::SquareMatrix<int, 2>;
+//%template(Matrix22f) VecMat::SquareMatrix<float, 2>;
+//%template(Matrix22d) VecMat::SquareMatrix<double, 2>;
+
+//%template(Matrix22r) VecMat::SquareMatrix<real, 2>;
+//%template(Matrix33u) VecMat::SquareMatrix<unsigned, 3>;
+//%template(Matrix33i) VecMat::SquareMatrix<int, 3>;
+//%template(Matrix33f) VecMat::SquareMatrix<float, 3>;
+//%template(Matrix33d) VecMat::SquareMatrix<double, 3>;
+//%template(Matrix33r) VecMat::SquareMatrix<real, 3>;
+
+//%template(Matrix44u) VecMat::SquareMatrix<unsigned, 4>;
+//%template(Matrix44i) VecMat::SquareMatrix<int, 4>;
+//%template(Matrix44f) VecMat::SquareMatrix<float, 4>;
+//%template(Matrix44d) VecMat::SquareMatrix<double, 4>;
+//%template(Matrix44r) VecMat::SquareMatrix<real, 4>;
+
+%include "../geometry/Geom.h"
+
+// Noise
+%include "../geometry/Noise.h"
+
+// Material
+%include "../scene_graph/Material.h"
+
+// ViewMap Components
+%include "../winged_edge/Nature.h"
+
+%rename(getObject) Interface0DIterator::operator*;
+%rename(getObject) Interface0DIteratorNested::operator*;
+%include "../view_map/Interface0D.h"
+
+%include "../view_map/Interface1D.h"
+%template(integrateUnsigned)	integrate<unsigned>;
+%template(integrateFloat)	integrate<float>;
+%template(integrateDouble)	integrate<double>;
+//%template(integrateReal)	integrate<real>;
+
+%rename(getObject) FEdgeInternal::SVertexIterator::operator*;
+%rename(FEdgeSVertexIterator) FEdgeInternal::SVertexIterator;
+%include "../view_map/Silhouette.h"
+
+%template(ViewShapesContainer) std::vector<ViewShape*>;
+%template(ViewEdgesContainer) std::vector<ViewEdge*>;
+%template(FEdgesContainer) std::vector<FEdge*>;
+%template(ViewVerticesContainer) std::vector<ViewVertex*>;
+%template(SVerticesContainer) std::vector<SVertex*>;
+
+%ignore NonTVertex::edges_begin;
+%ignore NonTVertex::edges_last;
+%ignore NonTVertex::edges_iterator;
+%ignore TVertex::edges_begin;
+%ignore TVertex::edges_last;
+%ignore TVertex::edges_iterator;
+%ignore ViewEdge::ViewEdge_iterator;
+%ignore ViewEdge::fedge_iterator_begin;
+%ignore ViewEdge::fedge_iterator_last;
+%ignore ViewEdge::fedge_iterator_end;
+%ignore ViewEdge::vertices_begin;
+%ignore ViewEdge::vertices_last;
+%ignore ViewEdge::vertices_end;
+%rename(directedViewEdge) ViewVertex::directedViewEdge; 
+//%template(directedViewEdge) std::pair<ViewEdge*,bool>;
+%include "../view_map/ViewMap.h"
+
+
+%feature("director") ViewEdgeInternal::ViewEdgeIterator;
+%rename(getObject) ViewVertexInternal::orientedViewEdgeIterator::operator*;
+%rename(ViewVertexOrientedViewEdgeIterator) ViewVertexInternal::orientedViewEdgeIterator;
+%rename(getObject) ViewEdgeInternal::SVertexIterator::operator*;
+%rename(ViewEdgeSVertexIterator) ViewEdgeInternal::SVertexIterator;
+%rename(getObject) ViewEdgeInternal::ViewEdgeIterator::operator*;
+%rename(ViewEdgeViewEdgeIterator) ViewEdgeInternal::ViewEdgeIterator;
+%include "../view_map/ViewMapIterators.h"
+
+%include "../view_map/Interface0D.h"
+
+// SWIG directives in "../view_map/Functions0D.h"
+%ignore Functions0D::getFEdges;
+%ignore Functions0D::getViewEdges;
+%ignore Functions0D::getShapeF0D;
+%ignore Functions0D::getOccludersF0D;
+%ignore Functions0D::getOccludeeF0D;
+%include "../view_map/Functions0D.h"
+
+// SWIG directives in "../view_map/Functions1D.h"
+%ignore Functions1D::getOccludeeF1D;
+%ignore Functions1D::getOccludersF1D;
+%ignore Functions1D::getShapeF1D;
+%include "../view_map/Functions1D.h"
+
+// Module parameters
+%include "../stroke/Module.h"
+
+%include "../stroke/AdvancedFunctions0D.h"
+%include "../stroke/AdvancedFunctions1D.h"
+
+%include "../stroke/ContextFunctions.h"
+
+%rename(getObject) AdjacencyIterator::operator*;
+%rename(getObject) ViewEdgeInternal::ViewEdgeIterator::operator*;
+%feature("director") ChainingIterator;
+%feature("director") ChainSilhouetteIterator;
+%feature("director") ChainPredicateIterator;
+%include "../stroke/ChainingIterators.h"
+
+%feature("director") UnaryPredicate0D;
+%include "../stroke/Predicates0D.h"
+
+%feature("director") UnaryPredicate1D;
+%feature("director") BinaryPredicate1D;
+%include "../stroke/Predicates1D.h"
+%include "../stroke/AdvancedPredicates1D.h"
+
+%rename(getObject) CurveInternal::CurvePointIterator::operator*;
+%rename(CurvePointIterator) CurveInternal::CurvePointIterator;
+%include "../stroke/CurveIterators.h"
+
+%ignore Curve::points_begin;
+%ignore Curve::points_end;
+%ignore Curve::vertices_begin;
+%ignore Curve::vertices_end;
+%include "../stroke/Curve.h"
+
+%ignore Stroke::vertices_begin;
+%ignore Stroke::vertices_end;
+%include "../stroke/StrokeIterators.h"
+%include "../stroke/Stroke.h"
+
+%rename(getObject) StrokeInternal::StrokeVertexIterator::operator*;
+%rename(StrokeVertexIterator) StrokeInternal::StrokeVertexIterator;
+%include "../stroke/StrokeIterators.h"
+
+%feature("director") StrokeShader;
+%template(ShadersContainer) std::vector<StrokeShader*>;
+%include "../stroke/StrokeShader.h"
+
+%include "../stroke/BasicStrokeShaders.h"
+%include "../stroke/AdvancedStrokeShaders.h"
+
+%ignore Operators::getStrokesSet;
+%ignore Operators::reset;
+%include "../stroke/Operators.h"
+
+// Canvas.h
+%include "../stroke/Canvas.h"
+
+// Cast functions
+%include "../system/Cast.h"
+%template(castToSVertex)	Cast::cast<Interface0D, SVertex>;
+%template(castToViewVertex)	Cast::cast<Interface0D, ViewVertex>;
+%template(castToTVertex)	Cast::cast<Interface0D, TVertex>;
+%template(castToCurvePoint)	Cast::cast<Interface0D, CurvePoint>;
+%template(castToStrokeVertex)	Cast::cast<Interface0D, StrokeVertex>;
+%template(castToNonTVertex)	Cast::cast<Interface0D, NonTVertex>;
+%template(castToFEdge)		Cast::cast<Interface1D, FEdge>;
+%template(castToViewEdge)	Cast::cast<Interface1D, ViewEdge>;
+%template(castToStroke)		Cast::cast<Interface1D, Stroke>;
+%template(castToChain)		Cast::cast<Interface1D, Chain>;
diff --git a/source/blender/freestyle/intern/swig/FreestyleWrapper.vc7.vcproj b/source/blender/freestyle/intern/swig/FreestyleWrapper.vc7.vcproj
new file mode 100755
index 00000000000..060c1987ea1
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/FreestyleWrapper.vc7.vcproj
@@ -0,0 +1,217 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="_Freestyle"
+	ProjectGUID="{3E3D60D3-0904-4DC7-BFC2-113735CA00DD}"
+	SccProjectName=""
+	SccLocalPath="">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				AdditionalIncludeDirectories="$(PYTHON_INCLUDE),..\stroke,..\system,..\geometry,..\winged_edge,..\view_map,..\image,..\scene_graph"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;FREESTYLEWRAPPER_EXPORTS"
+				StringPooling="TRUE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="TRUE"
+				RuntimeTypeInfo="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\Release/FreestyleWrapper.vc6.pch"
+				AssemblerListingLocation=".\Release/"
+				ObjectFile=".\Release/"
+				ProgramDataBaseFileName=".\Release/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\build\win32\release\FreestyleWingedEdge2.2.lib ..\..\build\win32\release\FreestyleViewMap2.2.lib ..\..\build\win32\release\FreestyleSystem2.2.lib ..\..\build\win32\release\FreestyleStroke2.2.lib ..\..\build\win32\release\FreestyleRendering2.2.lib ..\..\build\win32\release\FreestyleGeometry2.2.lib ..\..\build\win32\release\FreestyleImage2.2.lib odbc32.lib odbccp32.lib C:\python24\libs\python24.lib"
+				OutputFile="..\..\build\win32\release\python\_Freestyle.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ProgramDatabaseFile=".\Release/_Freestyle.pdb"
+				ImportLibrary=".\Release/_Freestyle.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Release/FreestyleWrapper.vc6.tlb"
+				HeaderFileName=""/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy   Freestyle.py   ..\..\build\win32\release\python\"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="2057"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(PYTHON_INCLUDE),..\stroke,..\system,..\geometry,..\winged_edge,..\view_map,..\image,..\scene_graph"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;FREESTYLEWRAPPER_EXPORTS;__WIN32__"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				RuntimeTypeInfo="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\Debug/FreestyleWrapper.vc6.pch"
+				AssemblerListingLocation=".\Debug/"
+				ObjectFile=".\Debug/"
+				ProgramDataBaseFileName=".\Debug/"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\build\win32\debug\FreestyleWingedEdge_d2.2.lib ..\..\build\win32\debug\FreestyleViewMap_d2.2.lib ..\..\build\win32\debug\FreestyleSystem_d2.2.lib ..\..\build\win32\debug\FreestyleStroke_d2.2.lib ..\..\build\win32\debug\FreestyleRendering_d2.2.lib ..\..\build\win32\debug\FreestyleGeometry_d2.2.lib ..\..\build\win32\debug\FreestyleImage_d2.2.lib odbc32.lib odbccp32.lib C:\Python24\libs\python24_d.lib"
+				OutputFile="..\..\build\win32\debug\python\_Freestyle.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/_Freestyle.pdb"
+				ImportLibrary=".\Debug/_Freestyle.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/FreestyleWrapper.vc6.tlb"
+				HeaderFileName=""/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy   Freestyle.py   ..\..\build\win32\debug\python\"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="2057"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
+			<File
+				RelativePath="ModuleWrapper.cpp">
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						Optimization="2"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_MBCS;_USRDLL;FREESTYLEWRAPPER_EXPORTS;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						Optimization="0"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_MBCS;_USRDLL;FREESTYLEWRAPPER_EXPORTS;__WIN32__;$(NoInherit)"
+						BasicRuntimeChecks="3"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl">
+			<File
+				RelativePath="ModuleWrapper.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
+		</Filter>
+		<File
+			RelativePath="Freestyle.i">
+			<FileConfiguration
+				Name="Release|Win32">
+				<Tool
+					Name="VCCustomBuildTool"
+					CommandLine="echo In order to function correctly, please ensure the following environment variables are correctly set:
+echo PYTHON_INCLUDE: %PYTHON_INCLUDE%
+echo PYTHON_LIB: %PYTHON_LIB%
+echo on
+swig -c++ -python  -I&quot;$(SWIG_INC)\python&quot; -I&quot;$(SWIG_INC)&quot; -o ModuleWrapper.cpp &quot;$(InputPath)&quot;
+"
+					Outputs="ModuleWrapper.cpp"/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Debug|Win32">
+				<Tool
+					Name="VCCustomBuildTool"
+					CommandLine="echo In order to function correctly, please ensure the following environment variables are correctly set:
+echo PYTHON_INCLUDE: %PYTHON_INCLUDE%
+echo PYTHON_LIB: %PYTHON_LIB%
+echo on
+swig -c++ -python -I&quot;$(SWIG_INC)\python&quot; -I&quot;$(SWIG_INC)&quot; -o ModuleWrapper.cpp &quot;$(InputPath)&quot;
+"
+					Outputs="ModuleWrapper.cpp"/>
+			</FileConfiguration>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/source/blender/freestyle/intern/swig/FreestyleWrapper.vc8.vcproj b/source/blender/freestyle/intern/swig/FreestyleWrapper.vc8.vcproj
new file mode 100755
index 00000000000..833a4f89aca
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/FreestyleWrapper.vc8.vcproj
@@ -0,0 +1,283 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8,00"
+	Name="_Freestyle"
+	ProjectGUID="{E6FFBB76-729F-4C64-8A85-A420C4555FAF}"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="false"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="true"
+				SuppressStartupBanner="true"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Release/FreestyleWrapper.tlb"
+				HeaderFileName=""
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				AdditionalIncludeDirectories="$(PYTHON_INCLUDE),..\stroke,..\system,..\geometry,..\winged_edge,..\view_map,..\image,..\scene_graph"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;FREESTYLEWRAPPER_EXPORTS"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile=".\Release/FreestyleWrapper.pch"
+				AssemblerListingLocation=".\Release/"
+				ObjectFile=".\Release/"
+				ProgramDataBaseFileName=".\Release/"
+				WarningLevel="2"
+				SuppressStartupBanner="true"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="2057"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\build\win32\release\FreestyleWingedEdge2.2.lib ..\..\build\win32\release\FreestyleViewMap2.2.lib ..\..\build\win32\release\FreestyleSystem2.2.lib ..\..\build\win32\release\FreestyleStroke2.2.lib ..\..\build\win32\release\FreestyleRendering2.2.lib ..\..\build\win32\release\FreestyleGeometry2.2.lib ..\..\build\win32\release\FreestyleImage2.2.lib odbc32.lib odbccp32.lib $(PYTHON_LIB)"
+				OutputFile="..\..\build\win32\release\python\_Freestyle.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="true"
+				ProgramDatabaseFile=".\Release/_Freestyle.pdb"
+				ImportLibrary=".\Release/_Freestyle.lib"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+				SuppressStartupBanner="true"
+				OutputFile=".\Release/FreestyleWrapper.bsc"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy   Freestyle.py   ..\..\build\win32\release\python\&#x0D;&#x0A;copy   ..\..\build\win32\release\python\_Freestyle.dll   ..\..\build\win32\release\python\_Freestyle.pyd&#x0D;&#x0A;"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="false"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="true"
+				SuppressStartupBanner="true"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/FreestyleWrapper.tlb"
+				HeaderFileName=""
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(PYTHON_INCLUDE),..\stroke,..\system,..\geometry,..\winged_edge,..\view_map,..\image,..\scene_graph"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;FREESTYLEWRAPPER_EXPORTS;__WIN32__"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				RuntimeTypeInfo="true"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile=".\Debug/FreestyleWrapper.pch"
+				AssemblerListingLocation=".\Debug/"
+				ObjectFile=".\Debug/"
+				ProgramDataBaseFileName=".\Debug/"
+				WarningLevel="2"
+				SuppressStartupBanner="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="2057"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\build\win32\debug\FreestyleWingedEdge_d2.2.lib ..\..\build\win32\debug\FreestyleViewMap_d2.2.lib ..\..\build\win32\debug\FreestyleSystem_d2.2.lib ..\..\build\win32\debug\FreestyleStroke_d2.2.lib ..\..\build\win32\debug\FreestyleRendering_d2.2.lib ..\..\build\win32\debug\FreestyleGeometry_d2.2.lib ..\..\build\win32\debug\FreestyleImage_d2.2.lib odbc32.lib odbccp32.lib $(PYTHON_LIB)"
+				OutputFile="..\..\build\win32\debug\python\_Freestyle.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="true"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile=".\Debug/_Freestyle.pdb"
+				ImportLibrary=".\Debug/_Freestyle.lib"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+				SuppressStartupBanner="true"
+				OutputFile=".\Debug/FreestyleWrapper.bsc"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+				CommandLine="copy   Freestyle.py   ..\..\build\win32\debug\python\&#x0D;&#x0A;copy   ..\..\build\win32\debug\python\_Freestyle.dll   ..\..\build\win32\debug\python\_Freestyle.pyd&#x0D;&#x0A;"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+			>
+			<File
+				RelativePath="ModuleWrapper.cpp"
+				>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions=""
+						UsePrecompiledHeader="0"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories=""
+						PreprocessorDefinitions=""
+						UsePrecompiledHeader="0"
+					/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl"
+			>
+			<File
+				RelativePath="ModuleWrapper.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+			>
+		</Filter>
+		<File
+			RelativePath="Freestyle.i"
+			>
+			<FileConfiguration
+				Name="Release|Win32"
+				>
+				<Tool
+					Name="VCCustomBuildTool"
+					CommandLine="echo In order to function correctly, please ensure the following environment variables are correctly set:&#x0D;&#x0A;echo PYTHON_INCLUDE: %PYTHON_INCLUDE%&#x0D;&#x0A;echo PYTHON_LIB: %PYTHON_LIB%&#x0D;&#x0A;echo on&#x0D;&#x0A;swig -c++ -python -I&quot;$(SWIG_INC)\python&quot; -I&quot;$(SWIG_INC)&quot; -o ModuleWrapper.cpp &quot;$(InputPath)&quot;&#x0D;&#x0A;"
+					Outputs="ModuleWrapper.cpp"
+				/>
+			</FileConfiguration>
+			<FileConfiguration
+				Name="Debug|Win32"
+				>
+				<Tool
+					Name="VCCustomBuildTool"
+					CommandLine="echo In order to function correctly, please ensure the following environment variables are correctly set:&#x0D;&#x0A;echo PYTHON_INCLUDE: %PYTHON_INCLUDE%&#x0D;&#x0A;echo PYTHON_LIB: %PYTHON_LIB%&#x0D;&#x0A;echo on&#x0D;&#x0A;swig -c++ -python  -I&quot;$(SWIG_INC)\python&quot; -I&quot;$(SWIG_INC)&quot; -o ModuleWrapper.cpp &quot;$(InputPath)&quot;&#x0D;&#x0A;"
+					Outputs="ModuleWrapper.cpp"
+				/>
+			</FileConfiguration>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/source/blender/freestyle/intern/swig/Makefile b/source/blender/freestyle/intern/swig/Makefile
new file mode 100755
index 00000000000..01829434be0
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Makefile
@@ -0,0 +1,90 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                             W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+CXX	  = g++
+RM	  = rm -f
+INSTALL	  = install
+SWIG	  = swig
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 4
+
+BUILD     = debug
+PLATEFORM = linux-g++
+MODNAME   = Freestyle
+
+LIBNAME   = _${MODNAME}.so
+LIBDIR    = ../../build/${PLATEFORM}/${BUILD}/lib/python
+IPATH     = -I../geometry -I../image -I../scene_graph -I../stroke \
+            -I../system -I../view_map -I../winged_edge \
+            -I/usr/include/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+# options to compile with static python : -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic
+#OPTI      = -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic #-O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+DBUG      = #-ggdb #-pg
+WARN	  = -w #-W -Wall #-pedantic -ansi
+
+CFLAGS    = ${OPTI} ${DBUG} ${WARN} ${IPATH}
+LDFLAGS   = ${OPTI} ${DBUG} ${WARN} ${LPATH}
+
+SWIG_SRC  = Freestyle.i
+PY_SRC    = ${SWIG_SRC:.i=.py}
+CXX_SRC	  = ModuleWrapper.cpp
+CXX_INC	  = ${CXX_SRC:.cpp=.h}
+CXX_OBJ	  = ${CXX_SRC:.cpp=.o}
+
+ifndef DBUG
+  STRIP   = strip --strip-all ${LIBDIR}/${LIBNAME}
+endif
+
+# # # # # # # # # # # # # # # #   R u l e s   # # # # # # # # # # # # # # # # #
+
+all	: swig cxx
+
+.PHONY	: clean re
+
+clean	: swig_clean cxx_clean
+
+re	: swig_re cxx_re
+
+# # # # # # # # # # # # #   S W I G   r u l e s   # # # # # # # # # # # # # # #
+
+.SUFFIXES:
+.SUFFIXES: .i .py .cpp .h .o
+
+.IGNORE	:
+
+swig	: ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+.i.py	: ${SWIG_SRC}
+	${SWIG} -c++ -python -o ${CXX_SRC} $<
+
+.PHONY	: swig_clean swig_re
+
+swig_clean	:
+	${RM} *~ \#* .\#* : ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+swig_re	: swig_clean swig
+
+# # # # # # # # #   P y t h o n   &   C + +   r u l e s   # # # # # # # # # # #
+
+cxx	: ${CXX_OBJ} ${PY_SRC}
+	${INSTALL} -d ${LIBDIR}
+	${CC} -shared -o ${LIBDIR}/${LIBNAME} ${CXX_OBJ}
+	${INSTALL} ${PY_SRC} ${LIBDIR}
+	@${STRIP}
+
+.cpp.o	: ${CXX_INC} ${CXX_SRC}
+	${CXX} ${CFLAGS} -c $< -o $@
+
+${CXX_SRC}	: ${PY_SRC}
+
+${CXX_INC}	: ${PY_SRC}
+
+.PHONY	: cxx_clean cxx_re
+
+cxx_clean	:
+	${RM} *~ \#* .\#* *.core gmon.out ${CXX_OBJ} 
+
+cxx_re	: cxx_clean cxx_all
diff --git a/source/blender/freestyle/intern/swig/Makefile.cygwin b/source/blender/freestyle/intern/swig/Makefile.cygwin
new file mode 100755
index 00000000000..1f5b3ce2a79
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Makefile.cygwin
@@ -0,0 +1,92 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                             W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+CXX	  = g++
+RM	  = rm -f
+INSTALL	  = install
+SWIG	  = swig
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 5
+
+BUILD     = debug
+PLATEFORM = cygwin-g++
+MODNAME   = Freestyle
+
+LIBNAME   = _${MODNAME}.dll
+LIBDIR    = ../../build/${PLATEFORM}/${BUILD}/lib/python
+IPATH     = -I../geometry -I../image -I../scene_graph -I../stroke \
+            -I../system -I../view_map -I../winged_edge \
+            -I/usr/include/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+LPATH     = -L/usr/lib/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}/config -lpython${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN} \
+            -L../../build/${PLATEFORM}/${BUILD}/lib -lFreestyleSystem -lFreestyleImage -lFreestyleGeometry -lFreestyleSceneGraph -lFreestyleWingedEdge -lFreestyleViewMap -lFreestyleRendering -lFreestyleStroke
+# options to compile with static python : -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic
+#OPTI      = -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic #-O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+DBUG      = #-ggdb #-pg
+WARN	  = -w #-W -Wall #-pedantic -ansi
+
+CFLAGS    = ${OPTI} ${DBUG} ${WARN} ${IPATH}
+LDFLAGS   = ${OPTI} ${DBUG} ${WARN} ${LPATH}
+
+SWIG_SRC  = Freestyle.i
+PY_SRC    = ${SWIG_SRC:.i=.py}
+CXX_SRC	  = ModuleWrapper.cpp
+CXX_INC	  = ${CXX_SRC:.cpp=.h}
+CXX_OBJ	  = ${CXX_SRC:.cpp=.o}
+
+ifndef DBUG
+  STRIP   = strip --strip-all ${LIBDIR}/${LIBNAME}
+endif
+
+# # # # # # # # # # # # # # # #   R u l e s   # # # # # # # # # # # # # # # # #
+
+all	: swig cxx
+
+.PHONY	: clean re
+
+clean	: swig_clean cxx_clean
+
+re	: swig_re cxx_re
+
+# # # # # # # # # # # # #   S W I G   r u l e s   # # # # # # # # # # # # # # #
+
+.SUFFIXES:
+.SUFFIXES: .i .py .cpp .h .o
+
+.IGNORE	:
+
+swig	: ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+.i.py	: ${SWIG_SRC}
+	${SWIG} -c++ -python -o ${CXX_SRC} $<
+
+.PHONY	: swig_clean swig_re
+
+swig_clean	:
+	${RM} *~ \#* .\#* : ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+swig_re	: swig_clean swig
+
+# # # # # # # # #   P y t h o n   &   C + +   r u l e s   # # # # # # # # # # #
+
+cxx	: ${CXX_OBJ} ${PY_SRC}
+	${INSTALL} -d ${LIBDIR}
+	${CXX} -shared ${LDFLAGS} -o ${LIBDIR}/${LIBNAME} ${CXX_OBJ}
+	${INSTALL} ${PY_SRC} ${LIBDIR}
+	@${STRIP}
+
+.cpp.o	: ${CXX_INC} ${CXX_SRC}
+	${CXX} ${CFLAGS} -c $< -o $@
+
+${CXX_SRC}	: ${PY_SRC}
+
+${CXX_INC}	: ${PY_SRC}
+
+.PHONY	: cxx_clean cxx_re
+
+cxx_clean	:
+	${RM} *~ \#* .\#* *.core gmon.out ${CXX_OBJ} 
+
+cxx_re	: cxx_clean cxx_all
diff --git a/source/blender/freestyle/intern/swig/Makefile.linux b/source/blender/freestyle/intern/swig/Makefile.linux
new file mode 100755
index 00000000000..2a93971ccd5
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Makefile.linux
@@ -0,0 +1,91 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                             W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+CXX	  = g++
+RM	  = rm -f
+INSTALL	  = install
+SWIG	  = swig
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 5
+
+BUILD     = debug
+PLATEFORM = linux-g++
+MODNAME   = Freestyle
+
+LIBNAME   = _${MODNAME}.so
+LIBDIR    = ../../build/${PLATEFORM}/${BUILD}/lib/python
+IPATH     = -I../geometry -I../image -I../scene_graph -I../stroke \
+            -I../system -I../view_map -I../winged_edge \
+            -I/usr/include/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+LPATH     = -L/usr/lib/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}/config -lpython${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+# options to compile with static python : -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic
+#OPTI      = -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic #-O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+DBUG      = #-ggdb #-pg
+WARN	  = -w #-W -Wall #-pedantic -ansi
+
+CFLAGS    = ${OPTI} ${DBUG} ${WARN} ${IPATH}
+LDFLAGS   = ${OPTI} ${DBUG} ${WARN} ${LPATH}
+
+SWIG_SRC  = Freestyle.i
+PY_SRC    = ${SWIG_SRC:.i=.py}
+CXX_SRC	  = ModuleWrapper.cpp
+CXX_INC	  = ${CXX_SRC:.cpp=.h}
+CXX_OBJ	  = ${CXX_SRC:.cpp=.o}
+
+ifndef DBUG
+  STRIP   = strip --strip-all ${LIBDIR}/${LIBNAME}
+endif
+
+# # # # # # # # # # # # # # # #   R u l e s   # # # # # # # # # # # # # # # # #
+
+all	: swig cxx
+
+.PHONY	: clean re
+
+clean	: swig_clean cxx_clean
+
+re	: swig_re cxx_re
+
+# # # # # # # # # # # # #   S W I G   r u l e s   # # # # # # # # # # # # # # #
+
+.SUFFIXES:
+.SUFFIXES: .i .py .cpp .h .o
+
+.IGNORE	:
+
+swig	: ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+.i.py	: ${SWIG_SRC}
+	${SWIG} -c++ -python -o ${CXX_SRC} $<
+
+.PHONY	: swig_clean swig_re
+
+swig_clean	:
+	${RM} *~ \#* .\#* : ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+swig_re	: swig_clean swig
+
+# # # # # # # # #   P y t h o n   &   C + +   r u l e s   # # # # # # # # # # #
+
+cxx	: ${CXX_OBJ} ${PY_SRC}
+	${INSTALL} -d ${LIBDIR}
+	${CXX} -shared ${LDFLAGS} -o ${LIBDIR}/${LIBNAME} ${CXX_OBJ}
+	${INSTALL} ${PY_SRC} ${LIBDIR}
+	@${STRIP}
+
+.cpp.o	: ${CXX_INC} ${CXX_SRC}
+	${CXX} ${CFLAGS} -c $< -o $@
+
+${CXX_SRC}	: ${PY_SRC}
+
+${CXX_INC}	: ${PY_SRC}
+
+.PHONY	: cxx_clean cxx_re
+
+cxx_clean	:
+	${RM} *~ \#* .\#* *.core gmon.out ${CXX_OBJ} 
+
+cxx_re	: cxx_clean cxx_all
diff --git a/source/blender/freestyle/intern/swig/Makefile.mac b/source/blender/freestyle/intern/swig/Makefile.mac
new file mode 100644
index 00000000000..2c46d74549e
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Makefile.mac
@@ -0,0 +1,91 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                             W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+CXX	  = g++
+RM	  = rm -f
+INSTALL	  = install
+SWIG	  = swig
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 5
+
+BUILD     = release
+PLATEFORM = macosx
+MODNAME   = Freestyle
+
+LIBNAME   = _${MODNAME}.so
+LIBDIR    = ../../build/${PLATEFORM}/${BUILD}/lib/python
+IPATH     = -I../geometry -I../image -I../scene_graph -I../stroke \
+            -I../system -I../view_map -I../winged_edge \
+            -I/usr/include/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+LPATH     = -L/usr/lib/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}/config -lpython${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+# options to compile with static python : -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic
+#OPTI      = -lpthread -lm -lutil -shared -Xlinker -x -export-dynamic #-O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+DBUG      = #-ggdb #-pg
+WARN	  = -w #-W -Wall #-pedantic -ansi
+
+CFLAGS    = ${OPTI} ${DBUG} ${WARN} ${IPATH}
+LDFLAGS   = ${OPTI} ${DBUG} ${WARN} ${LPATH}
+
+SWIG_SRC  = Freestyle.i
+PY_SRC    = ${SWIG_SRC:.i=.py}
+CXX_SRC	  = ModuleWrapper.cpp
+CXX_INC	  = ${CXX_SRC:.cpp=.h}
+CXX_OBJ	  = ${CXX_SRC:.cpp=.o}
+
+ifndef DBUG
+  STRIP   = strip -x ${LIBDIR}/${LIBNAME}
+endif
+
+# # # # # # # # # # # # # # # #   R u l e s   # # # # # # # # # # # # # # # # #
+
+all	: swig cxx
+
+.PHONY	: clean re
+
+clean	: swig_clean cxx_clean
+
+re	: swig_re cxx_re
+
+# # # # # # # # # # # # #   S W I G   r u l e s   # # # # # # # # # # # # # # #
+
+.SUFFIXES:
+.SUFFIXES: .i .py .cpp .h .o
+
+.IGNORE	:
+
+swig	: ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+.i.py	: ${SWIG_SRC}
+	${SWIG} -c++ -python -o ${CXX_SRC} $<
+
+.PHONY	: swig_clean swig_re
+
+swig_clean	:
+	${RM} *~ \#* .\#* : ${CXX_INC} ${CXX_SRC} ${PY_SRC}
+
+swig_re	: swig_clean swig
+
+# # # # # # # # #   P y t h o n   &   C + +   r u l e s   # # # # # # # # # # #
+
+cxx	: ${CXX_OBJ} ${PY_SRC}
+	${INSTALL} -d ${LIBDIR}
+	${CXX} -bundle -flat_namespace -undefined suppress ${LDFLAGS} -o ${LIBDIR}/${LIBNAME} ${CXX_OBJ}
+	${INSTALL} ${PY_SRC} ${LIBDIR}
+	@${STRIP}
+
+.cpp.o	: ${CXX_INC} ${CXX_SRC}
+	${CXX} ${CFLAGS} -c $< -o $@
+
+${CXX_SRC}	: ${PY_SRC}
+
+${CXX_INC}	: ${PY_SRC}
+
+.PHONY	: cxx_clean cxx_re
+
+cxx_clean	:
+	${RM} *~ \#* .\#* *.core gmon.out ${CXX_OBJ} 
+
+cxx_re	: cxx_clean cxx_all
diff --git a/source/blender/freestyle/intern/swig/Makefile.noswig b/source/blender/freestyle/intern/swig/Makefile.noswig
new file mode 100755
index 00000000000..368c4fb173b
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/Makefile.noswig
@@ -0,0 +1,64 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                             W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+CXX	  = g++
+RM	  = rm -f
+INSTALL	  = install
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 2
+
+BUILD     = debug
+PLATEFORM = linux-g++
+MODNAME   = Freestyle
+
+LIBNAME   = _${MODNAME}.so
+LIBDIR    = ../../build/${PLATEFORM}/${BUILD}/lib/python
+IPATH     = -I../geometry -I../image -I../scene_graph -I../stroke \
+            -I../system -I../view_map -I../winged_edge \
+            -I/usr/include/python${PYTHON_VERSION_MAJ}.${PYTHON_VERSION_MIN}
+OPTI      = #-O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+DBUG      = #-ggdb #-pg
+WARN	  = -w #-W -Wall #-pedantic -ansi
+
+CFLAGS    = ${OPTI} ${DBUG} ${WARN} ${IPATH}
+LDFLAGS   = ${OPTI} ${DBUG} ${WARN} ${LPATH}
+
+PY_SRC    = Freestyle.py
+CXX_SRC	  = ModuleWrapper.cpp
+CXX_INC	  = ${CXX_SRC:.cpp=.h}
+CXX_OBJ	  = ${CXX_SRC:.cpp=.o}
+
+ifndef DBUG
+  STRIP   = strip --strip-all ${LIBDIR}/${LIBNAME}
+endif
+
+# # # # # # # # # # # # # # # #   R u l e s   # # # # # # # # # # # # # # # # #
+
+all	: cxx
+
+.PHONY	: clean re
+
+clean	:  cxx_clean
+
+re	:  cxx_re
+
+# # # # # # # # #   P y t h o n   &   C + +   r u l e s   # # # # # # # # # # #
+
+cxx	: ${CXX_OBJ} ${PY_SRC}
+	${INSTALL} -d ${LIBDIR}
+	${CC} -shared -o ${LIBDIR}/${LIBNAME} ${CXX_OBJ}
+	${INSTALL} ${PY_SRC} ${LIBDIR}
+	@${STRIP}
+
+.cpp.o	: ${CXX_INC} ${CXX_SRC}
+	${CXX} ${CFLAGS} -c $< -o $@
+
+.PHONY	: cxx_clean cxx_re
+
+cxx_clean	:
+	${RM} *~ \#* .\#* *.core gmon.out ${CXX_OBJ} 
+
+cxx_re	: cxx_clean cxx_all
diff --git a/source/blender/freestyle/intern/swig/ModuleWrapper.cpp b/source/blender/freestyle/intern/swig/ModuleWrapper.cpp
new file mode 100755
index 00000000000..792388b52cb
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/ModuleWrapper.cpp
@@ -0,0 +1,111915 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.31
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGPYTHON
+#define SWIG_DIRECTORS
+#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
+
+#ifdef __cplusplus
+template<class T> class SwigValueWrapper {
+    T *tt;
+public:
+    SwigValueWrapper() : tt(0) { }
+    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
+    SwigValueWrapper(const T& t) : tt(new T(t)) { }
+    ~SwigValueWrapper() { delete tt; } 
+    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
+    operator T&() const { return *tt; }
+    T *operator&() { return tt; }
+private:
+    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+};
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC)
+#   if (__SUNPRO_CC <= 0x560)
+#     define SWIGTEMPLATEDISAMBIGUATOR template
+#   else
+#     define SWIGTEMPLATEDISAMBIGUATOR 
+#   endif
+# else
+#   define SWIGTEMPLATEDISAMBIGUATOR 
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__)) 
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__)) 
+# else
+#   define SWIGUNUSED 
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#  ifndef GCC_HASCLASSVISIBILITY
+#    define GCC_HASCLASSVISIBILITY
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif 
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+
+/* Python.h has to appear first */
+#include <Python.h>
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic CAPI SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "3"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the swig runtime code.
+  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  
+  But only do this if is strictly necessary, ie, if you have problems
+  with your compiler or so.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/* 
+   Flags/methods for returning states.
+   
+   The swig conversion methods, as ConvertPtr, return and integer 
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+   
+   Use the following macros/flags to set or process the returning
+   states.
+   
+   In old swig versions, you usually write code as:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit as:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   that seems to be the same, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+    
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   requires also to SWIG_ConvertPtr to return new result values, as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {         
+        if (<obj is ok>) {			       
+          if (<need new object>) {		       
+            *ptr = <ptr to new allocated object>; 
+            return SWIG_NEWOBJ;		       
+          } else {				       
+            *ptr = <ptr to old object>;	       
+            return SWIG_OLDOBJ;		       
+          } 				       
+        } else {				       
+          return SWIG_BADOBJ;		       
+        }					       
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   swig errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+ 
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+
+
+ */
+#define SWIG_OK                    (0) 
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) { 
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) { 
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store inforomation on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/* 
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (l1 - f1) - (l2 - f2);
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  int equiv = 0;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (!equiv && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+  int equiv = 0;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (!equiv && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+
+/* think of this as a c++ template<> or a scheme macro */
+#define SWIG_TypeCheck_Template(comparison, ty)         \
+  if (ty) {                                             \
+    swig_cast_info *iter = ty->cast;                    \
+    while (iter) {                                      \
+      if (comparison) {                                 \
+        if (iter == ty->cast) return iter;              \
+        /* Move iter to the top of the linked list */   \
+        iter->prev->next = iter->next;                  \
+        if (iter->next)                                 \
+          iter->next->prev = iter->prev;                \
+        iter->next = ty->cast;                          \
+        iter->prev = 0;                                 \
+        if (ty->cast) ty->cast->prev = iter;            \
+        ty->cast = iter;                                \
+        return iter;                                    \
+      }                                                 \
+      iter = iter->next;                                \
+    }                                                   \
+  }                                                     \
+  return 0
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+}
+
+/* Same as previous function, except strcmp is replaced with a pointer comparison */
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
+  SWIG_TypeCheck_Template(iter->type == from, into);
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+}
+
+/* 
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/* 
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+  
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }    
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+  
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+  
+  We start searching at module start, and finish searching when start == end.  
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start, 
+                            swig_module_info *end, 
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      register size_t l = 0;
+      register size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	register size_t i = (l + r) >> 1; 
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  register int compare = strcmp(name, iname);
+	  if (compare == 0) {	    
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+  
+  We start searching at module start, and finish searching when start == end.  
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start, 
+                     swig_module_info *end, 
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      register size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+  
+  /* neither found a match */
+  return 0;
+}
+
+/* 
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  register const unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    register unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/* 
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else 
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else 
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/* 
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1 
+#define  SWIG_IOError        	   -2 
+#define  SWIG_RuntimeError   	   -3 
+#define  SWIG_IndexError     	   -4 
+#define  SWIG_TypeError      	   -5 
+#define  SWIG_DivisionByZero 	   -6 
+#define  SWIG_OverflowError  	   -7 
+#define  SWIG_SyntaxError    	   -8 
+#define  SWIG_ValueError     	   -9 
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12 
+#define  SWIG_NullReferenceError   -13
+
+
+
+
+/* Add PyOS_snprintf for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
+#  define PyOS_snprintf _snprintf
+# else
+#  define PyOS_snprintf snprintf
+# endif
+#endif
+
+/* A crude PyString_FromFormat implementation for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+
+#ifndef SWIG_PYBUFFER_SIZE
+# define SWIG_PYBUFFER_SIZE 1024
+#endif
+
+static PyObject *
+PyString_FromFormat(const char *fmt, ...) {
+  va_list ap;
+  char buf[SWIG_PYBUFFER_SIZE * 2];
+  int res;
+  va_start(ap, fmt);
+  res = vsnprintf(buf, sizeof(buf), fmt, ap);
+  va_end(ap);
+  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
+}
+#endif
+
+/* Add PyObject_Del for old Pythons */
+#if PY_VERSION_HEX < 0x01060000
+# define PyObject_Del(op) PyMem_DEL((op))
+#endif
+#ifndef PyObject_DEL
+# define PyObject_DEL PyObject_Del
+#endif
+
+/* A crude PyExc_StopIteration exception for old Pythons */
+#if PY_VERSION_HEX < 0x02020000
+# ifndef PyExc_StopIteration
+#  define PyExc_StopIteration PyExc_RuntimeError
+# endif
+# ifndef PyObject_GenericGetAttr
+#  define PyObject_GenericGetAttr 0
+# endif
+#endif
+/* Py_NotImplemented is defined in 2.1 and up. */
+#if PY_VERSION_HEX < 0x02010000
+# ifndef Py_NotImplemented
+#  define Py_NotImplemented PyExc_RuntimeError
+# endif
+#endif
+
+
+/* A crude PyString_AsStringAndSize implementation for old Pythons */
+#if PY_VERSION_HEX < 0x02010000
+# ifndef PyString_AsStringAndSize
+#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
+# endif
+#endif
+
+/* PySequence_Size for old Pythons */
+#if PY_VERSION_HEX < 0x02000000
+# ifndef PySequence_Size
+#  define PySequence_Size PySequence_Length
+# endif
+#endif
+
+
+/* PyBool_FromLong for old Pythons */
+#if PY_VERSION_HEX < 0x02030000
+static
+PyObject *PyBool_FromLong(long ok)
+{
+  PyObject *result = ok ? Py_True : Py_False;
+  Py_INCREF(result);
+  return result;
+}
+#endif
+
+/* Py_ssize_t for old Pythons */
+/* This code is as recommended by: */
+/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
+typedef int Py_ssize_t;
+# define PY_SSIZE_T_MAX INT_MAX
+# define PY_SSIZE_T_MIN INT_MIN
+#endif
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGRUNTIME PyObject*
+SWIG_Python_ErrorType(int code) {
+  PyObject* type = 0;
+  switch(code) {
+  case SWIG_MemoryError:
+    type = PyExc_MemoryError;
+    break;
+  case SWIG_IOError:
+    type = PyExc_IOError;
+    break;
+  case SWIG_RuntimeError:
+    type = PyExc_RuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = PyExc_IndexError;
+    break;
+  case SWIG_TypeError:
+    type = PyExc_TypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = PyExc_ZeroDivisionError;
+    break;
+  case SWIG_OverflowError:
+    type = PyExc_OverflowError;
+    break;
+  case SWIG_SyntaxError:
+    type = PyExc_SyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = PyExc_ValueError;
+    break;
+  case SWIG_SystemError:
+    type = PyExc_SystemError;
+    break;
+  case SWIG_AttributeError:
+    type = PyExc_AttributeError;
+    break;
+  default:
+    type = PyExc_RuntimeError;
+  }
+  return type;
+}
+
+
+SWIGRUNTIME void
+SWIG_Python_AddErrorMsg(const char* mesg)
+{
+  PyObject *type = 0;
+  PyObject *value = 0;
+  PyObject *traceback = 0;
+
+  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
+  if (value) {
+    PyObject *old_str = PyObject_Str(value);
+    PyErr_Clear();
+    Py_XINCREF(type);
+    PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+    Py_DECREF(old_str);
+    Py_DECREF(value);
+  } else {
+    PyErr_Format(PyExc_RuntimeError, mesg);
+  }
+}
+
+
+
+#if defined(SWIG_PYTHON_NO_THREADS)
+#  if defined(SWIG_PYTHON_THREADS)
+#    undef SWIG_PYTHON_THREADS
+#  endif
+#endif
+#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
+#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
+#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
+#      define SWIG_PYTHON_USE_GIL
+#    endif
+#  endif
+#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
+#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
+#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
+#    endif
+#    ifdef __cplusplus /* C++ code */
+       class SWIG_Python_Thread_Block {
+         bool status;
+         PyGILState_STATE state;
+       public:
+         void end() { if (status) { PyGILState_Release(state); status = false;} }
+         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
+         ~SWIG_Python_Thread_Block() { end(); }
+       };
+       class SWIG_Python_Thread_Allow {
+         bool status;
+         PyThreadState *save;
+       public:
+         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
+         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
+         ~SWIG_Python_Thread_Allow() { end(); }
+       };
+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
+#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
+#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
+#    else /* C code */
+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
+#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
+#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
+#    endif
+#  else /* Old thread way, not implemented, user must provide it */
+#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
+#      define SWIG_PYTHON_INITIALIZE_THREADS
+#    endif
+#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
+#    endif
+#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
+#      define SWIG_PYTHON_THREAD_END_BLOCK
+#    endif
+#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
+#    endif
+#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
+#      define SWIG_PYTHON_THREAD_END_ALLOW
+#    endif
+#  endif
+#else /* No thread support */
+#  define SWIG_PYTHON_INITIALIZE_THREADS
+#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
+#  define SWIG_PYTHON_THREAD_END_BLOCK
+#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
+#  define SWIG_PYTHON_THREAD_END_ALLOW
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Python API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* cc-mode */
+#endif
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Constant declarations
+ * ----------------------------------------------------------------------------- */
+
+/* Constant Types */
+#define SWIG_PY_POINTER 4
+#define SWIG_PY_BINARY  5
+
+/* Constant information structure */
+typedef struct swig_const_info {
+  int type;
+  char *name;
+  long lvalue;
+  double dvalue;
+  void   *pvalue;
+  swig_type_info **ptype;
+} swig_const_info;
+
+#ifdef __cplusplus
+#if 0
+{ /* cc-mode */
+#endif
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * pyrun.swg
+ *
+ * This file contains the runtime support for Python modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ *
+ * ----------------------------------------------------------------------------- */
+
+/* Common SWIG API */
+
+/* for raw pointers */
+#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
+#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
+#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
+#define swig_owntype                                    int
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
+#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
+#define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
+
+#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
+#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
+#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
+#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
+#define SWIG_fail                        		goto fail					   
+
+
+/* Runtime API implementation */
+
+/* Error manipulation */
+
+SWIGINTERN void 
+SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
+  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
+  PyErr_SetObject(errtype, obj);
+  Py_DECREF(obj);
+  SWIG_PYTHON_THREAD_END_BLOCK;
+}
+
+SWIGINTERN void 
+SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
+  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+  PyErr_SetString(errtype, (char *) msg);
+  SWIG_PYTHON_THREAD_END_BLOCK;
+}
+
+#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
+
+/* Set a constant value */
+
+SWIGINTERN void
+SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
+  PyDict_SetItemString(d, (char*) name, obj);
+  Py_DECREF(obj);                            
+}
+
+/* Append a value to the result obj */
+
+SWIGINTERN PyObject*
+SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
+#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
+  if (!result) {
+    result = obj;
+  } else if (result == Py_None) {
+    Py_DECREF(result);
+    result = obj;
+  } else {
+    if (!PyList_Check(result)) {
+      PyObject *o2 = result;
+      result = PyList_New(1);
+      PyList_SetItem(result, 0, o2);
+    }
+    PyList_Append(result,obj);
+    Py_DECREF(obj);
+  }
+  return result;
+#else
+  PyObject*   o2;
+  PyObject*   o3;
+  if (!result) {
+    result = obj;
+  } else if (result == Py_None) {
+    Py_DECREF(result);
+    result = obj;
+  } else {
+    if (!PyTuple_Check(result)) {
+      o2 = result;
+      result = PyTuple_New(1);
+      PyTuple_SET_ITEM(result, 0, o2);
+    }
+    o3 = PyTuple_New(1);
+    PyTuple_SET_ITEM(o3, 0, obj);
+    o2 = result;
+    result = PySequence_Concat(o2, o3);
+    Py_DECREF(o2);
+    Py_DECREF(o3);
+  }
+  return result;
+#endif
+}
+
+/* Unpack the argument tuple */
+
+SWIGINTERN int
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
+{
+  if (!args) {
+    if (!min && !max) {
+      return 1;
+    } else {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
+		   name, (min == max ? "" : "at least "), min);
+      return 0;
+    }
+  }  
+  if (!PyTuple_Check(args)) {
+    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
+    return 0;
+  } else {
+    register int l = PyTuple_GET_SIZE(args);
+    if (l < min) {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
+		   name, (min == max ? "" : "at least "), min, l);
+      return 0;
+    } else if (l > max) {
+      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
+		   name, (min == max ? "" : "at most "), max, l);
+      return 0;
+    } else {
+      register int i;
+      for (i = 0; i < l; ++i) {
+	objs[i] = PyTuple_GET_ITEM(args, i);
+      }
+      for (; l < max; ++l) {
+	objs[l] = 0;
+      }
+      return i + 1;
+    }    
+  }
+}
+
+/* A functor is a function object with one single object argument */
+#if PY_VERSION_HEX >= 0x02020000
+#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
+#else
+#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
+#endif
+
+/*
+  Helper for static pointer initialization for both C and C++ code, for example
+  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
+*/
+#ifdef __cplusplus
+#define SWIG_STATIC_POINTER(var)  var
+#else
+#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Pointer declarations
+ * ----------------------------------------------------------------------------- */
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
+#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
+
+#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* cc-mode */
+#endif
+#endif
+
+/*  How to access Py_None */
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#  ifndef SWIG_PYTHON_NO_BUILD_NONE
+#    ifndef SWIG_PYTHON_BUILD_NONE
+#      define SWIG_PYTHON_BUILD_NONE
+#    endif
+#  endif
+#endif
+
+#ifdef SWIG_PYTHON_BUILD_NONE
+#  ifdef Py_None
+#   undef Py_None
+#   define Py_None SWIG_Py_None()
+#  endif
+SWIGRUNTIMEINLINE PyObject * 
+_SWIG_Py_None(void)
+{
+  PyObject *none = Py_BuildValue((char*)"");
+  Py_DECREF(none);
+  return none;
+}
+SWIGRUNTIME PyObject * 
+SWIG_Py_None(void)
+{
+  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
+  return none;
+}
+#endif
+
+/* The python void return value */
+
+SWIGRUNTIMEINLINE PyObject * 
+SWIG_Py_Void(void)
+{
+  PyObject *none = Py_None;
+  Py_INCREF(none);
+  return none;
+}
+
+/* PySwigClientData */
+
+typedef struct {
+  PyObject *klass;
+  PyObject *newraw;
+  PyObject *newargs;
+  PyObject *destroy;
+  int delargs;
+  int implicitconv;
+} PySwigClientData;
+
+SWIGRUNTIMEINLINE int 
+SWIG_Python_CheckImplicit(swig_type_info *ty)
+{
+  PySwigClientData *data = (PySwigClientData *)ty->clientdata;
+  return data ? data->implicitconv : 0;
+}
+
+SWIGRUNTIMEINLINE PyObject *
+SWIG_Python_ExceptionType(swig_type_info *desc) {
+  PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
+  PyObject *klass = data ? data->klass : 0;
+  return (klass ? klass : PyExc_RuntimeError);
+}
+
+
+SWIGRUNTIME PySwigClientData * 
+PySwigClientData_New(PyObject* obj)
+{
+  if (!obj) {
+    return 0;
+  } else {
+    PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
+    /* the klass element */
+    data->klass = obj;
+    Py_INCREF(data->klass);
+    /* the newraw method and newargs arguments used to create a new raw instance */
+    if (PyClass_Check(obj)) {
+      data->newraw = 0;
+      data->newargs = obj;
+      Py_INCREF(obj);
+    } else {
+#if (PY_VERSION_HEX < 0x02020000)
+      data->newraw = 0;
+#else
+      data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
+#endif
+      if (data->newraw) {
+	Py_INCREF(data->newraw);
+	data->newargs = PyTuple_New(1);
+	PyTuple_SetItem(data->newargs, 0, obj);
+      } else {
+	data->newargs = obj;
+      }
+      Py_INCREF(data->newargs);
+    }
+    /* the destroy method, aka as the C++ delete method */
+    data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
+    if (PyErr_Occurred()) {
+      PyErr_Clear();
+      data->destroy = 0;
+    }
+    if (data->destroy) {
+      int flags;
+      Py_INCREF(data->destroy);
+      flags = PyCFunction_GET_FLAGS(data->destroy);
+#ifdef METH_O
+      data->delargs = !(flags & (METH_O));
+#else
+      data->delargs = 0;
+#endif
+    } else {
+      data->delargs = 0;
+    }
+    data->implicitconv = 0;
+    return data;
+  }
+}
+
+SWIGRUNTIME void 
+PySwigClientData_Del(PySwigClientData* data)
+{
+  Py_XDECREF(data->newraw);
+  Py_XDECREF(data->newargs);
+  Py_XDECREF(data->destroy);
+}
+
+/* =============== PySwigObject =====================*/
+
+typedef struct {
+  PyObject_HEAD
+  void *ptr;
+  swig_type_info *ty;
+  int own;
+  PyObject *next;
+} PySwigObject;
+
+SWIGRUNTIME PyObject *
+PySwigObject_long(PySwigObject *v)
+{
+  return PyLong_FromVoidPtr(v->ptr);
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_format(const char* fmt, PySwigObject *v)
+{
+  PyObject *res = NULL;
+  PyObject *args = PyTuple_New(1);
+  if (args) {
+    if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
+      PyObject *ofmt = PyString_FromString(fmt);
+      if (ofmt) {
+	res = PyString_Format(ofmt,args);
+	Py_DECREF(ofmt);
+      }
+      Py_DECREF(args);
+    }
+  }
+  return res;
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_oct(PySwigObject *v)
+{
+  return PySwigObject_format("%o",v);
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_hex(PySwigObject *v)
+{
+  return PySwigObject_format("%x",v);
+}
+
+SWIGRUNTIME PyObject *
+#ifdef METH_NOARGS
+PySwigObject_repr(PySwigObject *v)
+#else
+PySwigObject_repr(PySwigObject *v, PyObject *args)
+#endif
+{
+  const char *name = SWIG_TypePrettyName(v->ty);
+  PyObject *hex = PySwigObject_hex(v);    
+  PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
+  Py_DECREF(hex);
+  if (v->next) {
+#ifdef METH_NOARGS
+    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
+#else
+    PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
+#endif
+    PyString_ConcatAndDel(&repr,nrep);
+  }
+  return repr;  
+}
+
+SWIGRUNTIME int
+PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+{
+#ifdef METH_NOARGS
+  PyObject *repr = PySwigObject_repr(v);
+#else
+  PyObject *repr = PySwigObject_repr(v, NULL);
+#endif
+  if (repr) {
+    fputs(PyString_AsString(repr), fp);
+    Py_DECREF(repr);
+    return 0; 
+  } else {
+    return 1; 
+  }
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_str(PySwigObject *v)
+{
+  char result[SWIG_BUFFER_SIZE];
+  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
+    PyString_FromString(result) : 0;
+}
+
+SWIGRUNTIME int
+PySwigObject_compare(PySwigObject *v, PySwigObject *w)
+{
+  void *i = v->ptr;
+  void *j = w->ptr;
+  return (i < j) ? -1 : ((i > j) ? 1 : 0);
+}
+
+SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
+
+SWIGRUNTIME PyTypeObject*
+PySwigObject_type(void) {
+  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
+  return type;
+}
+
+SWIGRUNTIMEINLINE int
+PySwigObject_Check(PyObject *op) {
+  return ((op)->ob_type == PySwigObject_type())
+    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_New(void *ptr, swig_type_info *ty, int own);
+
+SWIGRUNTIME void
+PySwigObject_dealloc(PyObject *v)
+{
+  PySwigObject *sobj = (PySwigObject *) v;
+  PyObject *next = sobj->next;
+  if (sobj->own) {
+    swig_type_info *ty = sobj->ty;
+    PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+    PyObject *destroy = data ? data->destroy : 0;
+    if (destroy) {
+      /* destroy is always a VARARGS method */
+      PyObject *res;
+      if (data->delargs) {
+	/* we need to create a temporal object to carry the destroy operation */
+	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
+	res = SWIG_Python_CallFunctor(destroy, tmp);
+	Py_DECREF(tmp);
+      } else {
+	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+	PyObject *mself = PyCFunction_GET_SELF(destroy);
+	res = ((*meth)(mself, v));
+      }
+      Py_XDECREF(res);
+    } else {
+      const char *name = SWIG_TypePrettyName(ty);
+#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
+      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
+#endif
+    }
+  } 
+  Py_XDECREF(next);
+  PyObject_DEL(v);
+}
+
+SWIGRUNTIME PyObject* 
+PySwigObject_append(PyObject* v, PyObject* next)
+{
+  PySwigObject *sobj = (PySwigObject *) v;
+#ifndef METH_O
+  PyObject *tmp = 0;
+  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
+  next = tmp;
+#endif
+  if (!PySwigObject_Check(next)) {
+    return NULL;
+  }
+  sobj->next = next;
+  Py_INCREF(next);
+  return SWIG_Py_Void();
+}
+
+SWIGRUNTIME PyObject* 
+#ifdef METH_NOARGS
+PySwigObject_next(PyObject* v)
+#else
+PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  PySwigObject *sobj = (PySwigObject *) v;
+  if (sobj->next) {    
+    Py_INCREF(sobj->next);
+    return sobj->next;
+  } else {
+    return SWIG_Py_Void();
+  }
+}
+
+SWIGINTERN PyObject*
+#ifdef METH_NOARGS
+PySwigObject_disown(PyObject *v)
+#else
+PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  PySwigObject *sobj = (PySwigObject *)v;
+  sobj->own = 0;
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject*
+#ifdef METH_NOARGS
+PySwigObject_acquire(PyObject *v)
+#else
+PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
+#endif
+{
+  PySwigObject *sobj = (PySwigObject *)v;
+  sobj->own = SWIG_POINTER_OWN;
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject*
+PySwigObject_own(PyObject *v, PyObject *args)
+{
+  PyObject *val = 0;
+#if (PY_VERSION_HEX < 0x02020000)
+  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
+#else
+  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
+#endif
+    {
+      return NULL;
+    } 
+  else
+    {
+      PySwigObject *sobj = (PySwigObject *)v;
+      PyObject *obj = PyBool_FromLong(sobj->own);
+      if (val) {
+#ifdef METH_NOARGS
+	if (PyObject_IsTrue(val)) {
+	  PySwigObject_acquire(v);
+	} else {
+	  PySwigObject_disown(v);
+	}
+#else
+	if (PyObject_IsTrue(val)) {
+	  PySwigObject_acquire(v,args);
+	} else {
+	  PySwigObject_disown(v,args);
+	}
+#endif
+      } 
+      return obj;
+    }
+}
+
+#ifdef METH_O
+static PyMethodDef
+swigobject_methods[] = {
+  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
+  {0, 0, 0, 0}  
+};
+#else
+static PyMethodDef
+swigobject_methods[] = {
+  {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
+  {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
+  {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
+  {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
+  {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
+  {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
+  {0, 0, 0, 0}  
+};
+#endif
+
+#if PY_VERSION_HEX < 0x02020000
+SWIGINTERN PyObject *
+PySwigObject_getattr(PySwigObject *sobj,char *name)
+{
+  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
+}
+#endif
+
+SWIGRUNTIME PyTypeObject*
+_PySwigObject_type(void) {
+  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
+  
+  static PyNumberMethods PySwigObject_as_number = {
+    (binaryfunc)0, /*nb_add*/
+    (binaryfunc)0, /*nb_subtract*/
+    (binaryfunc)0, /*nb_multiply*/
+    (binaryfunc)0, /*nb_divide*/
+    (binaryfunc)0, /*nb_remainder*/
+    (binaryfunc)0, /*nb_divmod*/
+    (ternaryfunc)0,/*nb_power*/
+    (unaryfunc)0,  /*nb_negative*/
+    (unaryfunc)0,  /*nb_positive*/
+    (unaryfunc)0,  /*nb_absolute*/
+    (inquiry)0,    /*nb_nonzero*/
+    0,		   /*nb_invert*/
+    0,		   /*nb_lshift*/
+    0,		   /*nb_rshift*/
+    0,		   /*nb_and*/
+    0,		   /*nb_xor*/
+    0,		   /*nb_or*/
+    (coercion)0,   /*nb_coerce*/
+    (unaryfunc)PySwigObject_long, /*nb_int*/
+    (unaryfunc)PySwigObject_long, /*nb_long*/
+    (unaryfunc)0,                 /*nb_float*/
+    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
+    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
+#if PY_VERSION_HEX >= 0x02020000
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
+#elif PY_VERSION_HEX >= 0x02000000
+    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
+#endif
+  };
+
+  static PyTypeObject pyswigobject_type;  
+  static int type_init = 0;
+  if (!type_init) {
+    const PyTypeObject tmp
+      = {
+	PyObject_HEAD_INIT(NULL)
+	0,				    /* ob_size */
+	(char *)"PySwigObject",		    /* tp_name */
+	sizeof(PySwigObject),		    /* tp_basicsize */
+	0,			            /* tp_itemsize */
+	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
+	(printfunc)PySwigObject_print,	    /* tp_print */
+#if PY_VERSION_HEX < 0x02020000
+	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
+#else
+	(getattrfunc)0,			    /* tp_getattr */ 
+#endif
+	(setattrfunc)0,			    /* tp_setattr */ 
+	(cmpfunc)PySwigObject_compare,	    /* tp_compare */ 
+	(reprfunc)PySwigObject_repr,	    /* tp_repr */    
+	&PySwigObject_as_number,	    /* tp_as_number */
+	0,				    /* tp_as_sequence */
+	0,				    /* tp_as_mapping */
+	(hashfunc)0,			    /* tp_hash */
+	(ternaryfunc)0,			    /* tp_call */
+	(reprfunc)PySwigObject_str,	    /* tp_str */
+	PyObject_GenericGetAttr,            /* tp_getattro */
+	0,				    /* tp_setattro */
+	0,		                    /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
+	swigobject_doc, 	            /* tp_doc */        
+	0,                                  /* tp_traverse */
+	0,                                  /* tp_clear */
+	0,                                  /* tp_richcompare */
+	0,                                  /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+	0,                                  /* tp_iter */
+	0,                                  /* tp_iternext */
+	swigobject_methods,		    /* tp_methods */ 
+	0,			            /* tp_members */
+	0,				    /* tp_getset */	    	
+	0,			            /* tp_base */	        
+	0,				    /* tp_dict */	    	
+	0,				    /* tp_descr_get */  	
+	0,				    /* tp_descr_set */  	
+	0,				    /* tp_dictoffset */ 	
+	0,				    /* tp_init */	    	
+	0,				    /* tp_alloc */	    	
+	0,			            /* tp_new */	    	
+	0,	                            /* tp_free */	   
+        0,                                  /* tp_is_gc */  
+	0,				    /* tp_bases */   
+	0,				    /* tp_mro */
+	0,				    /* tp_cache */   
+ 	0,				    /* tp_subclasses */
+	0,				    /* tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+	0,                                  /* tp_del */
+#endif
+#ifdef COUNT_ALLOCS
+	0,0,0,0                             /* tp_alloc -> tp_next */
+#endif
+      };
+    pyswigobject_type = tmp;
+    pyswigobject_type.ob_type = &PyType_Type;
+    type_init = 1;
+  }
+  return &pyswigobject_type;
+}
+
+SWIGRUNTIME PyObject *
+PySwigObject_New(void *ptr, swig_type_info *ty, int own)
+{
+  PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
+  if (sobj) {
+    sobj->ptr  = ptr;
+    sobj->ty   = ty;
+    sobj->own  = own;
+    sobj->next = 0;
+  }
+  return (PyObject *)sobj;
+}
+
+/* -----------------------------------------------------------------------------
+ * Implements a simple Swig Packed type, and use it instead of string
+ * ----------------------------------------------------------------------------- */
+
+typedef struct {
+  PyObject_HEAD
+  void *pack;
+  swig_type_info *ty;
+  size_t size;
+} PySwigPacked;
+
+SWIGRUNTIME int
+PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
+{
+  char result[SWIG_BUFFER_SIZE];
+  fputs("<Swig Packed ", fp); 
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
+    fputs("at ", fp); 
+    fputs(result, fp); 
+  }
+  fputs(v->ty->name,fp); 
+  fputs(">", fp);
+  return 0; 
+}
+  
+SWIGRUNTIME PyObject *
+PySwigPacked_repr(PySwigPacked *v)
+{
+  char result[SWIG_BUFFER_SIZE];
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
+    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
+  } else {
+    return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
+  }  
+}
+
+SWIGRUNTIME PyObject *
+PySwigPacked_str(PySwigPacked *v)
+{
+  char result[SWIG_BUFFER_SIZE];
+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
+    return PyString_FromFormat("%s%s", result, v->ty->name);
+  } else {
+    return PyString_FromString(v->ty->name);
+  }  
+}
+
+SWIGRUNTIME int
+PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
+{
+  size_t i = v->size;
+  size_t j = w->size;
+  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
+  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
+}
+
+SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
+
+SWIGRUNTIME PyTypeObject*
+PySwigPacked_type(void) {
+  static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
+  return type;
+}
+
+SWIGRUNTIMEINLINE int
+PySwigPacked_Check(PyObject *op) {
+  return ((op)->ob_type == _PySwigPacked_type()) 
+    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
+}
+
+SWIGRUNTIME void
+PySwigPacked_dealloc(PyObject *v)
+{
+  if (PySwigPacked_Check(v)) {
+    PySwigPacked *sobj = (PySwigPacked *) v;
+    free(sobj->pack);
+  }
+  PyObject_DEL(v);
+}
+
+SWIGRUNTIME PyTypeObject*
+_PySwigPacked_type(void) {
+  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
+  static PyTypeObject pyswigpacked_type;
+  static int type_init = 0;  
+  if (!type_init) {
+    const PyTypeObject tmp
+      = {
+	PyObject_HEAD_INIT(NULL)
+	0,				    /* ob_size */	
+	(char *)"PySwigPacked",		    /* tp_name */	
+	sizeof(PySwigPacked),		    /* tp_basicsize */	
+	0,				    /* tp_itemsize */	
+	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */	
+	(printfunc)PySwigPacked_print,	    /* tp_print */   	
+	(getattrfunc)0,			    /* tp_getattr */ 	
+	(setattrfunc)0,			    /* tp_setattr */ 	
+	(cmpfunc)PySwigPacked_compare,	    /* tp_compare */ 	
+	(reprfunc)PySwigPacked_repr,	    /* tp_repr */    	
+	0,	                            /* tp_as_number */	
+	0,				    /* tp_as_sequence */
+	0,				    /* tp_as_mapping */	
+	(hashfunc)0,			    /* tp_hash */	
+	(ternaryfunc)0,			    /* tp_call */	
+	(reprfunc)PySwigPacked_str,	    /* tp_str */	
+	PyObject_GenericGetAttr,            /* tp_getattro */
+	0,				    /* tp_setattro */
+	0,		                    /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
+	swigpacked_doc, 	            /* tp_doc */
+	0,                                  /* tp_traverse */
+	0,                                  /* tp_clear */
+	0,                                  /* tp_richcompare */
+	0,                                  /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+	0,                                  /* tp_iter */
+	0,                                  /* tp_iternext */
+	0,		                    /* tp_methods */ 
+	0,			            /* tp_members */
+	0,				    /* tp_getset */	    	
+	0,			            /* tp_base */	        
+	0,				    /* tp_dict */	    	
+	0,				    /* tp_descr_get */  	
+	0,				    /* tp_descr_set */  	
+	0,				    /* tp_dictoffset */ 	
+	0,				    /* tp_init */	    	
+	0,				    /* tp_alloc */	    	
+	0,			            /* tp_new */	    	
+	0, 	                            /* tp_free */	   
+        0,                                  /* tp_is_gc */  
+	0,				    /* tp_bases */   
+	0,				    /* tp_mro */
+	0,				    /* tp_cache */   
+ 	0,				    /* tp_subclasses */
+	0,				    /* tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+	0,                                  /* tp_del */
+#endif
+#ifdef COUNT_ALLOCS
+	0,0,0,0                             /* tp_alloc -> tp_next */
+#endif
+      };
+    pyswigpacked_type = tmp;
+    pyswigpacked_type.ob_type = &PyType_Type;
+    type_init = 1;
+  }
+  return &pyswigpacked_type;
+}
+
+SWIGRUNTIME PyObject *
+PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
+{
+  PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
+  if (sobj) {
+    void *pack = malloc(size);
+    if (pack) {
+      memcpy(pack, ptr, size);
+      sobj->pack = pack;
+      sobj->ty   = ty;
+      sobj->size = size;
+    } else {
+      PyObject_DEL((PyObject *) sobj);
+      sobj = 0;
+    }
+  }
+  return (PyObject *) sobj;
+}
+
+SWIGRUNTIME swig_type_info *
+PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
+{
+  if (PySwigPacked_Check(obj)) {
+    PySwigPacked *sobj = (PySwigPacked *)obj;
+    if (sobj->size != size) return 0;
+    memcpy(ptr, sobj->pack, size);
+    return sobj->ty;
+  } else {
+    return 0;
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+SWIGRUNTIMEINLINE PyObject *
+_SWIG_This(void)
+{
+  return PyString_FromString("this");
+}
+
+SWIGRUNTIME PyObject *
+SWIG_This(void)
+{
+  static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
+  return swig_this;
+}
+
+/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
+
+SWIGRUNTIME PySwigObject *
+SWIG_Python_GetSwigThis(PyObject *pyobj) 
+{
+  if (PySwigObject_Check(pyobj)) {
+    return (PySwigObject *) pyobj;
+  } else {
+    PyObject *obj = 0;
+#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
+    if (PyInstance_Check(pyobj)) {
+      obj = _PyInstance_Lookup(pyobj, SWIG_This());      
+    } else {
+      PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
+      if (dictptr != NULL) {
+	PyObject *dict = *dictptr;
+	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
+      } else {
+#ifdef PyWeakref_CheckProxy
+	if (PyWeakref_CheckProxy(pyobj)) {
+	  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
+	  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
+	}
+#endif
+	obj = PyObject_GetAttr(pyobj,SWIG_This());
+	if (obj) {
+	  Py_DECREF(obj);
+	} else {
+	  if (PyErr_Occurred()) PyErr_Clear();
+	  return 0;
+	}
+      }
+    }
+#else
+    obj = PyObject_GetAttr(pyobj,SWIG_This());
+    if (obj) {
+      Py_DECREF(obj);
+    } else {
+      if (PyErr_Occurred()) PyErr_Clear();
+      return 0;
+    }
+#endif
+    if (obj && !PySwigObject_Check(obj)) {
+      /* a PyObject is called 'this', try to get the 'real this'
+	 PySwigObject from it */ 
+      return SWIG_Python_GetSwigThis(obj);
+    }
+    return (PySwigObject *)obj;
+  }
+}
+
+/* Acquire a pointer value */
+
+SWIGRUNTIME int
+SWIG_Python_AcquirePtr(PyObject *obj, int own) {
+  if (own) {
+    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+    if (sobj) {
+      int oldown = sobj->own;
+      sobj->own = own;
+      return oldown;
+    }
+  }
+  return 0;
+}
+
+/* Convert a pointer value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
+  if (!obj) return SWIG_ERROR;
+  if (obj == Py_None) {
+    if (ptr) *ptr = 0;
+    return SWIG_OK;
+  } else {
+    PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+    while (sobj) {
+      void *vptr = sobj->ptr;
+      if (ty) {
+	swig_type_info *to = sobj->ty;
+	if (to == ty) {
+	  /* no type cast needed */
+	  if (ptr) *ptr = vptr;
+	  break;
+	} else {
+	  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+	  if (!tc) {
+	    sobj = (PySwigObject *)sobj->next;
+	  } else {
+	    if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
+	    break;
+	  }
+	}
+      } else {
+	if (ptr) *ptr = vptr;
+	break;
+      }
+    }
+    if (sobj) {
+      if (own) *own = sobj->own;
+      if (flags & SWIG_POINTER_DISOWN) {
+	sobj->own = 0;
+      }
+      return SWIG_OK;
+    } else {
+      int res = SWIG_ERROR;
+      if (flags & SWIG_POINTER_IMPLICIT_CONV) {
+	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+	if (data && !data->implicitconv) {
+	  PyObject *klass = data->klass;
+	  if (klass) {
+	    PyObject *impconv;
+	    data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
+	    impconv = SWIG_Python_CallFunctor(klass, obj);
+	    data->implicitconv = 0;
+	    if (PyErr_Occurred()) {
+	      PyErr_Clear();
+	      impconv = 0;
+	    }
+	    if (impconv) {
+	      PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
+	      if (iobj) {
+		void *vptr;
+		res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
+		if (SWIG_IsOK(res)) {
+		  if (ptr) {
+		    *ptr = vptr;
+		    /* transfer the ownership to 'ptr' */
+		    iobj->own = 0;
+		    res = SWIG_AddCast(res);
+		    res = SWIG_AddNewMask(res);
+		  } else {
+		    res = SWIG_AddCast(res);		    
+		  }
+		}
+	      }
+	      Py_DECREF(impconv);
+	    }
+	  }
+	}
+      }
+      return res;
+    }
+  }
+}
+
+/* Convert a function ptr value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
+  if (!PyCFunction_Check(obj)) {
+    return SWIG_ConvertPtr(obj, ptr, ty, 0);
+  } else {
+    void *vptr = 0;
+    
+    /* here we get the method pointer for callbacks */
+    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
+    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
+    if (desc) {
+      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
+      if (!desc) return SWIG_ERROR;
+    }
+    if (ty) {
+      swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
+      if (!tc) return SWIG_ERROR;
+      *ptr = SWIG_TypeCast(tc,vptr);
+    } else {
+      *ptr = vptr;
+    }
+    return SWIG_OK;
+  }
+}
+
+/* Convert a packed value value */
+
+SWIGRUNTIME int
+SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
+  swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
+  if (!to) return SWIG_ERROR;
+  if (ty) {
+    if (to != ty) {
+      /* check type cast? */
+      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+      if (!tc) return SWIG_ERROR;
+    }
+  }
+  return SWIG_OK;
+}  
+
+/* -----------------------------------------------------------------------------
+ * Create a new pointer object
+ * ----------------------------------------------------------------------------- */
+
+/*
+  Create a new instance object, whitout calling __init__, and set the
+  'this' attribute.
+*/
+
+SWIGRUNTIME PyObject* 
+SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
+{
+#if (PY_VERSION_HEX >= 0x02020000)
+  PyObject *inst = 0;
+  PyObject *newraw = data->newraw;
+  if (newraw) {
+    inst = PyObject_Call(newraw, data->newargs, NULL);
+    if (inst) {
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+      PyObject **dictptr = _PyObject_GetDictPtr(inst);
+      if (dictptr != NULL) {
+	PyObject *dict = *dictptr;
+	if (dict == NULL) {
+	  dict = PyDict_New();
+	  *dictptr = dict;
+	  PyDict_SetItem(dict, SWIG_This(), swig_this);
+	}
+      }
+#else
+      PyObject *key = SWIG_This();
+      PyObject_SetAttr(inst, key, swig_this);
+#endif
+    }
+  } else {
+    PyObject *dict = PyDict_New();
+    PyDict_SetItem(dict, SWIG_This(), swig_this);
+    inst = PyInstance_NewRaw(data->newargs, dict);
+    Py_DECREF(dict);
+  }
+  return inst;
+#else
+#if (PY_VERSION_HEX >= 0x02010000)
+  PyObject *inst;
+  PyObject *dict = PyDict_New();
+  PyDict_SetItem(dict, SWIG_This(), swig_this);
+  inst = PyInstance_NewRaw(data->newargs, dict);
+  Py_DECREF(dict);
+  return (PyObject *) inst;
+#else
+  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
+  if (inst == NULL) {
+    return NULL;
+  }
+  inst->in_class = (PyClassObject *)data->newargs;
+  Py_INCREF(inst->in_class);
+  inst->in_dict = PyDict_New();
+  if (inst->in_dict == NULL) {
+    Py_DECREF(inst);
+    return NULL;
+  }
+#ifdef Py_TPFLAGS_HAVE_WEAKREFS
+  inst->in_weakreflist = NULL;
+#endif
+#ifdef Py_TPFLAGS_GC
+  PyObject_GC_Init(inst);
+#endif
+  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
+  return (PyObject *) inst;
+#endif
+#endif
+}
+
+SWIGRUNTIME void
+SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
+{
+ PyObject *dict;
+#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+ PyObject **dictptr = _PyObject_GetDictPtr(inst);
+ if (dictptr != NULL) {
+   dict = *dictptr;
+   if (dict == NULL) {
+     dict = PyDict_New();
+     *dictptr = dict;
+   }
+   PyDict_SetItem(dict, SWIG_This(), swig_this);
+   return;
+ }
+#endif
+ dict = PyObject_GetAttrString(inst, (char*)"__dict__");
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
+ Py_DECREF(dict);
+} 
+
+
+SWIGINTERN PyObject *
+SWIG_Python_InitShadowInstance(PyObject *args) {
+  PyObject *obj[2];
+  if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
+    return NULL;
+  } else {
+    PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
+    if (sthis) {
+      PySwigObject_append((PyObject*) sthis, obj[1]);
+    } else {
+      SWIG_Python_SetSwigThis(obj[0], obj[1]);
+    }
+    return SWIG_Py_Void();
+  }
+}
+
+/* Create a new pointer object */
+
+SWIGRUNTIME PyObject *
+SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+  if (!ptr) {
+    return SWIG_Py_Void();
+  } else {
+    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+    PyObject *robj = PySwigObject_New(ptr, type, own);
+    PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
+    if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
+      PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
+      if (inst) {
+	Py_DECREF(robj);
+	robj = inst;
+      }
+    }
+    return robj;
+  }
+}
+
+/* Create a new packed object */
+
+SWIGRUNTIMEINLINE PyObject *
+SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
+  return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
+}
+
+/* -----------------------------------------------------------------------------*
+ *  Get type list 
+ * -----------------------------------------------------------------------------*/
+
+#ifdef SWIG_LINK_RUNTIME
+void *SWIG_ReturnGlobalTypeList(void *);
+#endif
+
+SWIGRUNTIME swig_module_info *
+SWIG_Python_GetModule(void) {
+  static void *type_pointer = (void *)0;
+  /* first check if module already created */
+  if (!type_pointer) {
+#ifdef SWIG_LINK_RUNTIME
+    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
+#else
+    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
+				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
+    if (PyErr_Occurred()) {
+      PyErr_Clear();
+      type_pointer = (void *)0;
+    }
+#endif
+  }
+  return (swig_module_info *) type_pointer;
+}
+
+#if PY_MAJOR_VERSION < 2
+/* PyModule_AddObject function was introduced in Python 2.0.  The following function
+   is copied out of Python/modsupport.c in python version 2.3.4 */
+SWIGINTERN int
+PyModule_AddObject(PyObject *m, char *name, PyObject *o)
+{
+  PyObject *dict;
+  if (!PyModule_Check(m)) {
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs module as first arg");
+    return SWIG_ERROR;
+  }
+  if (!o) {
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs non-NULL value");
+    return SWIG_ERROR;
+  }
+  
+  dict = PyModule_GetDict(m);
+  if (dict == NULL) {
+    /* Internal error -- modules must have a dict! */
+    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
+		 PyModule_GetName(m));
+    return SWIG_ERROR;
+  }
+  if (PyDict_SetItemString(dict, name, o))
+    return SWIG_ERROR;
+  Py_DECREF(o);
+  return SWIG_OK;
+}
+#endif
+
+SWIGRUNTIME void
+SWIG_Python_DestroyModule(void *vptr)
+{
+  swig_module_info *swig_module = (swig_module_info *) vptr;
+  swig_type_info **types = swig_module->types;
+  size_t i;
+  for (i =0; i < swig_module->size; ++i) {
+    swig_type_info *ty = types[i];
+    if (ty->owndata) {
+      PySwigClientData *data = (PySwigClientData *) ty->clientdata;
+      if (data) PySwigClientData_Del(data);
+    }
+  }
+  Py_DECREF(SWIG_This());
+}
+
+SWIGRUNTIME void
+SWIG_Python_SetModule(swig_module_info *swig_module) {
+  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
+
+  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
+				   swig_empty_runtime_method_table);
+  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
+  if (pointer && module) {
+    PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
+  } else {
+    Py_XDECREF(pointer);
+  }
+}
+
+/* The python cached type query */
+SWIGRUNTIME PyObject *
+SWIG_Python_TypeCache(void) {
+  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
+  return cache;
+}
+
+SWIGRUNTIME swig_type_info *
+SWIG_Python_TypeQuery(const char *type)
+{
+  PyObject *cache = SWIG_Python_TypeCache();
+  PyObject *key = PyString_FromString(type); 
+  PyObject *obj = PyDict_GetItem(cache, key);
+  swig_type_info *descriptor;
+  if (obj) {
+    descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
+  } else {
+    swig_module_info *swig_module = SWIG_Python_GetModule();
+    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
+    if (descriptor) {
+      obj = PyCObject_FromVoidPtr(descriptor, NULL);
+      PyDict_SetItem(cache, key, obj);
+      Py_DECREF(obj);
+    }
+  }
+  Py_DECREF(key);
+  return descriptor;
+}
+
+/* 
+   For backward compatibility only
+*/
+#define SWIG_POINTER_EXCEPTION  0
+#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
+#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
+
+SWIGRUNTIME int
+SWIG_Python_AddErrMesg(const char* mesg, int infront)
+{
+  if (PyErr_Occurred()) {
+    PyObject *type = 0;
+    PyObject *value = 0;
+    PyObject *traceback = 0;
+    PyErr_Fetch(&type, &value, &traceback);
+    if (value) {
+      PyObject *old_str = PyObject_Str(value);
+      Py_XINCREF(type);
+      PyErr_Clear();
+      if (infront) {
+	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
+      } else {
+	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+      }
+      Py_DECREF(old_str);
+    }
+    return 1;
+  } else {
+    return 0;
+  }
+}
+  
+SWIGRUNTIME int
+SWIG_Python_ArgFail(int argnum)
+{
+  if (PyErr_Occurred()) {
+    /* add information about failing argument */
+    char mesg[256];
+    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
+    return SWIG_Python_AddErrMesg(mesg, 1);
+  } else {
+    return 0;
+  }
+}
+
+SWIGRUNTIMEINLINE const char *
+PySwigObject_GetDesc(PyObject *self)
+{
+  PySwigObject *v = (PySwigObject *)self;
+  swig_type_info *ty = v ? v->ty : 0;
+  return ty ? ty->str : (char*)"";
+}
+
+SWIGRUNTIME void
+SWIG_Python_TypeError(const char *type, PyObject *obj)
+{
+  if (type) {
+#if defined(SWIG_COBJECT_TYPES)
+    if (obj && PySwigObject_Check(obj)) {
+      const char *otype = (const char *) PySwigObject_GetDesc(obj);
+      if (otype) {
+	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
+		     type, otype);
+	return;
+      }
+    } else 
+#endif      
+    {
+      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
+      if (otype) {
+	PyObject *str = PyObject_Str(obj);
+	const char *cstr = str ? PyString_AsString(str) : 0;
+	if (cstr) {
+	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
+		       type, otype, cstr);
+	} else {
+	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
+		       type, otype);
+	}
+	Py_XDECREF(str);
+	return;
+      }
+    }   
+    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
+  } else {
+    PyErr_Format(PyExc_TypeError, "unexpected type is received");
+  }
+}
+
+
+/* Convert a pointer value, signal an exception on a type mismatch */
+SWIGRUNTIME void *
+SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
+  void *result;
+  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
+    PyErr_Clear();
+    if (flags & SWIG_POINTER_EXCEPTION) {
+      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
+      SWIG_Python_ArgFail(argnum);
+    }
+  }
+  return result;
+}
+
+
+#ifdef __cplusplus
+#if 0
+{ /* cc-mode */
+#endif
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
+
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * director.swg
+ *
+ * This file contains support for director classes that proxy
+ * method calls from C++ to Python extensions.
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
+#define SWIG_DIRECTOR_PYTHON_HEADER_
+
+#ifdef __cplusplus
+
+#include <string>
+#include <iostream>
+#include <exception>
+#include <vector>
+#include <map>
+
+
+/*
+  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
+  table', and avoid multiple GetAttr calls to retrieve the python
+  methods.
+*/
+
+#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE
+#ifndef SWIG_PYTHON_DIRECTOR_VTABLE
+#define SWIG_PYTHON_DIRECTOR_VTABLE
+#endif
+#endif
+
+
+
+/*
+  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
+  Undefined Exception Handler provided by swift
+*/
+#ifndef SWIG_DIRECTOR_NO_UEH
+#ifndef SWIG_DIRECTOR_UEH
+#define SWIG_DIRECTOR_UEH
+#endif
+#endif
+
+
+/*
+  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
+  'Swig' namespace. This could be usefull for multi-modules projects.
+*/
+#ifdef SWIG_DIRECTOR_STATIC
+/* Force anonymous (static) namespace */
+#define Swig
+#endif
+
+
+/*
+  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
+  native C++ RTTI and dynamic_cast<>. But be aware that directors
+  could stop working when using this option.
+*/
+#ifdef SWIG_DIRECTOR_NORTTI
+/* 
+   When we don't use the native C++ RTTI, we implement a minimal one
+   only for Directors.
+*/
+# ifndef SWIG_DIRECTOR_RTDIR
+# define SWIG_DIRECTOR_RTDIR
+#include <map>
+
+namespace Swig {
+  class Director;
+  SWIGINTERN std::map<void*,Director*>& get_rtdir_map() {
+    static std::map<void*,Director*> rtdir_map;
+    return rtdir_map;
+  }
+
+  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
+    get_rtdir_map()[vptr] = rtdir;
+  }
+
+  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
+    std::map<void*,Director*>::const_iterator pos = get_rtdir_map().find(vptr);
+    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
+    return rtdir;
+  }
+}
+# endif /* SWIG_DIRECTOR_RTDIR */
+
+# define SWIG_DIRECTOR_CAST(Arg) Swig::get_rtdir(static_cast<void*>(Arg))
+# define SWIG_DIRECTOR_RGTR(Arg1, Arg2) Swig::set_rtdir(static_cast<void*>(Arg1), Arg2)
+
+#else
+
+# define SWIG_DIRECTOR_CAST(Arg) dynamic_cast<Swig::Director*>(Arg)
+# define SWIG_DIRECTOR_RGTR(Arg1, Arg2)
+
+#endif /* SWIG_DIRECTOR_NORTTI */
+
+extern "C" {
+  struct swig_type_info;
+}
+
+namespace Swig {  
+
+  /* memory handler */
+  struct GCItem 
+  {
+    virtual ~GCItem() = 0;
+
+    virtual int get_own() const
+    {
+      return 0;
+    }
+  };
+
+  GCItem::~GCItem()
+  {
+  }
+
+  struct GCItem_var
+  {
+    GCItem_var(GCItem *item = 0) : _item(item)
+    {
+    }
+
+    GCItem_var& operator=(GCItem *item)
+    {
+      GCItem *tmp = _item;
+      _item = item;
+      delete tmp;
+      return *this;
+    }
+
+    ~GCItem_var() 
+    {
+      delete _item;
+    }
+    
+    GCItem * operator->() const
+    {
+      return _item;
+    }
+    
+  private:
+    GCItem *_item;
+  };
+  
+  struct GCItem_Object : GCItem
+  {
+    GCItem_Object(int own) : _own(own)
+    {
+    }
+    
+    virtual ~GCItem_Object() 
+    {
+    }
+
+    int get_own() const
+    {
+      return _own;
+    }
+    
+  private:
+    int _own;
+  };
+
+  template <typename Type>
+  struct GCItem_T : GCItem
+  {
+    GCItem_T(Type *ptr) : _ptr(ptr)
+    {
+    }
+    
+    virtual ~GCItem_T() 
+    {
+      delete _ptr;
+    }
+    
+  private:
+    Type *_ptr;
+  };
+
+  template <typename Type>
+  struct GCArray_T : GCItem
+  {
+    GCArray_T(Type *ptr) : _ptr(ptr)
+    {
+    }
+    
+    virtual ~GCArray_T() 
+    {
+      delete[] _ptr;
+    }
+    
+  private:
+    Type *_ptr;
+  };
+
+  /* base class for director exceptions */
+  class DirectorException {
+  protected:
+    std::string swig_msg;
+  public:
+    DirectorException(PyObject *error, const char* hdr ="", const char* msg ="") 
+      : swig_msg(hdr)
+    {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
+      if (strlen(msg)) {
+        swig_msg += " ";
+        swig_msg += msg;
+      }
+      if (!PyErr_Occurred()) {
+        PyErr_SetString(error, getMessage());
+      } else {
+        SWIG_Python_AddErrorMsg(getMessage());
+      }
+      SWIG_PYTHON_THREAD_END_BLOCK; 
+    }
+
+    const char *getMessage() const
+    { 
+      return swig_msg.c_str(); 
+    }
+
+    static void raise(PyObject *error, const char *msg) 
+    {
+      throw DirectorException(error, msg);
+    }
+
+    static void raise(const char *msg) 
+    {
+      raise(PyExc_RuntimeError, msg);
+    }
+  };
+
+  /* unknown exception handler  */
+  class UnknownExceptionHandler 
+  {
+#ifdef SWIG_DIRECTOR_UEH
+    static void handler()  {
+      try {
+        throw;
+      } catch (DirectorException& e) {
+        std::cerr << "Swig Director exception caught:" << std::endl
+                  << e.getMessage() << std::endl;
+      } catch (std::exception& e) {
+        std::cerr << "std::exception caught: "<< e.what() << std::endl;
+      } catch (...) {
+        std::cerr << "Unknown exception caught." << std::endl;
+      }
+      
+      std::cerr << std::endl
+                << "Python interpreter traceback:" << std::endl;
+      PyErr_Print();
+      std::cerr << std::endl;
+      
+      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
+                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
+                << std::endl
+                << "Exception is being re-thrown, program will like abort/terminate." << std::endl;
+      throw;
+    }
+
+  public:
+    
+    std::unexpected_handler old;
+    UnknownExceptionHandler(std::unexpected_handler nh = handler)
+    {
+      old = std::set_unexpected(nh);
+    }
+
+    ~UnknownExceptionHandler()
+    {
+      std::set_unexpected(old);
+    }
+#endif
+  };
+
+  /* type mismatch in the return value from a python method call */
+  class DirectorTypeMismatchException : public Swig::DirectorException {
+  public:
+    DirectorTypeMismatchException(PyObject *error, const char* msg="") 
+      : Swig::DirectorException(error, "Swig director type mismatch", msg)
+    {
+    }
+
+    DirectorTypeMismatchException(const char* msg="") 
+      : Swig::DirectorException(PyExc_TypeError, "Swig director type mismatch", msg)
+    {
+    }
+
+    static void raise(PyObject *error, const char *msg)
+    {
+      throw DirectorTypeMismatchException(error, msg);
+    }
+
+    static void raise(const char *msg)
+    {
+      throw DirectorTypeMismatchException(msg);
+    }
+  };
+
+  /* any python exception that occurs during a director method call */
+  class DirectorMethodException : public Swig::DirectorException {
+  public:
+    DirectorMethodException(const char* msg = "") 
+      : DirectorException(PyExc_RuntimeError, "Swig director method error", msg)
+    {
+    }    
+
+    static void raise(const char *msg)
+    {
+      throw DirectorMethodException(msg);
+    }
+  };
+
+  /* attempt to call a pure virtual method via a director method */
+  class DirectorPureVirtualException : public Swig::DirectorException
+  {
+  public:
+    DirectorPureVirtualException(const char* msg = "") 
+      : DirectorException(PyExc_RuntimeError, "Swig director pure virtual method called", msg)
+    { 
+    }
+
+    static void raise(const char *msg) 
+    {
+      throw DirectorPureVirtualException(msg);
+    }
+  };
+
+
+#if defined(SWIG_PYTHON_THREADS)
+/*  __THREAD__ is the old macro to activate some thread support */
+# if !defined(__THREAD__)
+#   define __THREAD__ 1
+# endif
+#endif
+
+/* simple thread abstraction for pthreads on win32 */
+#ifdef __THREAD__
+# define __PTHREAD__
+# if defined(_WIN32) || defined(__WIN32__)
+#  define pthread_mutex_lock EnterCriticalSection
+#  define pthread_mutex_unlock LeaveCriticalSection
+#  define pthread_mutex_t CRITICAL_SECTION
+#  define SWIG_MUTEX_INIT(var) var
+# else
+#  include <pthread.h>
+#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
+# endif
+#endif
+
+#ifdef  __PTHREAD__
+  struct Guard
+  {
+    pthread_mutex_t *_mutex;
+    
+    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
+    {
+      pthread_mutex_lock(_mutex);
+    }
+    
+    ~Guard()
+    {
+      pthread_mutex_unlock(_mutex);
+    }
+  };
+# define SWIG_GUARD(mutex) Guard _guard(mutex)
+#else
+# define SWIG_GUARD(mutex) 
+#endif
+
+  /* director base class */
+  class Director {
+  private:
+    /* pointer to the wrapped python object */
+    PyObject* swig_self;
+    /* flag indicating whether the object is owned by python or c++ */
+    mutable bool swig_disown_flag;
+
+    /* decrement the reference count of the wrapped python object */
+    void swig_decref() const { 
+      if (swig_disown_flag) {
+        SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
+        Py_DECREF(swig_self); 
+        SWIG_PYTHON_THREAD_END_BLOCK; 
+      }
+    }
+
+  public:
+    /* wrap a python object, optionally taking ownership */
+    Director(PyObject* self) : swig_self(self), swig_disown_flag(false) {
+      swig_incref();
+    }
+
+
+    /* discard our reference at destruction */
+    virtual ~Director() {
+      swig_decref(); 
+    }
+
+
+    /* return a pointer to the wrapped python object */
+    PyObject *swig_get_self() const { 
+      return swig_self; 
+    }
+
+    /* acquire ownership of the wrapped python object (the sense of "disown"
+     * is from python) */
+    void swig_disown() const { 
+      if (!swig_disown_flag) { 
+        swig_disown_flag=true;
+        swig_incref(); 
+      } 
+    }
+
+    /* increase the reference count of the wrapped python object */
+    void swig_incref() const { 
+      if (swig_disown_flag) {
+        Py_INCREF(swig_self); 
+      }
+    }
+
+    /* methods to implement pseudo protected director members */
+    virtual bool swig_get_inner(const char* /* name */) const {
+      return true;
+    }
+    
+    virtual void swig_set_inner(const char* /* name */, bool /* val */) const {
+    }
+
+  /* ownership management */
+  private:
+    typedef std::map<void*, GCItem_var> ownership_map;
+    mutable ownership_map owner;
+#ifdef __PTHREAD__
+    static pthread_mutex_t swig_mutex_own;
+#endif
+
+  public:
+    template <typename Type>
+    void swig_acquire_ownership_array(Type *vptr)  const
+    {
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        owner[vptr] = new GCArray_T<Type>(vptr);
+      }
+    }
+    
+    template <typename Type>
+    void swig_acquire_ownership(Type *vptr)  const
+    {
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        owner[vptr] = new GCItem_T<Type>(vptr);
+      }
+    }
+
+    void swig_acquire_ownership_obj(void *vptr, int own) const
+    {
+      if (vptr && own) {
+        SWIG_GUARD(swig_mutex_own);
+        owner[vptr] = new GCItem_Object(own);
+      }
+    }
+    
+    int swig_release_ownership(void *vptr) const
+    {
+      int own = 0;
+      if (vptr) {
+        SWIG_GUARD(swig_mutex_own);
+        ownership_map::iterator iter = owner.find(vptr);
+        if (iter != owner.end()) {
+          own = iter->second->get_own();
+          owner.erase(iter);
+        }
+      }
+      return own;
+    }
+  };
+
+#ifdef __PTHREAD__
+  pthread_mutex_t SWIG_MUTEX_INIT(Director::swig_mutex_own);
+#endif
+}
+
+#endif /* __cplusplus */
+
+
+#endif
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_AdjacencyIterator swig_types[0]
+#define SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t swig_types[1]
+#define SWIGTYPE_p_BinaryPredicate0D swig_types[2]
+#define SWIGTYPE_p_BinaryPredicate1D swig_types[3]
+#define SWIGTYPE_p_CalligraphicShader swig_types[4]
+#define SWIGTYPE_p_Canvas swig_types[5]
+#define SWIGTYPE_p_Chain swig_types[6]
+#define SWIGTYPE_p_ChainPredicateIterator swig_types[7]
+#define SWIGTYPE_p_ChainSilhouetteIterator swig_types[8]
+#define SWIGTYPE_p_ChainingIterator swig_types[9]
+#define SWIGTYPE_p_CurvatureInfo swig_types[10]
+#define SWIGTYPE_p_Curve swig_types[11]
+#define SWIGTYPE_p_CurveInternal__CurvePointIterator swig_types[12]
+#define SWIGTYPE_p_CurvePoint swig_types[13]
+#define SWIGTYPE_p_Curve__vertex_container__iterator swig_types[14]
+#define SWIGTYPE_p_FEdge swig_types[15]
+#define SWIGTYPE_p_FEdgeInternal__SVertexIterator swig_types[16]
+#define SWIGTYPE_p_FEdgeSharp swig_types[17]
+#define SWIGTYPE_p_FEdgeSmooth swig_types[18]
+#define SWIGTYPE_p_Functions0D__Curvature2DAngleF0D swig_types[19]
+#define SWIGTYPE_p_Functions0D__CurveNatureF0D swig_types[20]
+#define SWIGTYPE_p_Functions0D__DensityF0D swig_types[21]
+#define SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D swig_types[22]
+#define SWIGTYPE_p_Functions0D__GetOccludeeF0D swig_types[23]
+#define SWIGTYPE_p_Functions0D__GetOccludersF0D swig_types[24]
+#define SWIGTYPE_p_Functions0D__GetParameterF0D swig_types[25]
+#define SWIGTYPE_p_Functions0D__GetProjectedXF0D swig_types[26]
+#define SWIGTYPE_p_Functions0D__GetProjectedYF0D swig_types[27]
+#define SWIGTYPE_p_Functions0D__GetProjectedZF0D swig_types[28]
+#define SWIGTYPE_p_Functions0D__GetShapeF0D swig_types[29]
+#define SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D swig_types[30]
+#define SWIGTYPE_p_Functions0D__GetXF0D swig_types[31]
+#define SWIGTYPE_p_Functions0D__GetYF0D swig_types[32]
+#define SWIGTYPE_p_Functions0D__GetZF0D swig_types[33]
+#define SWIGTYPE_p_Functions0D__LocalAverageDepthF0D swig_types[34]
+#define SWIGTYPE_p_Functions0D__MaterialF0D swig_types[35]
+#define SWIGTYPE_p_Functions0D__Normal2DF0D swig_types[36]
+#define SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D swig_types[37]
+#define SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D swig_types[38]
+#define SWIGTYPE_p_Functions0D__ReadMapPixelF0D swig_types[39]
+#define SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D swig_types[40]
+#define SWIGTYPE_p_Functions0D__ShapeIdF0D swig_types[41]
+#define SWIGTYPE_p_Functions0D__VertexOrientation2DF0D swig_types[42]
+#define SWIGTYPE_p_Functions0D__VertexOrientation3DF0D swig_types[43]
+#define SWIGTYPE_p_Functions0D__ZDiscontinuityF0D swig_types[44]
+#define SWIGTYPE_p_Functions1D__ChainingTimeStampF1D swig_types[45]
+#define SWIGTYPE_p_Functions1D__Curvature2DAngleF1D swig_types[46]
+#define SWIGTYPE_p_Functions1D__CurveNatureF1D swig_types[47]
+#define SWIGTYPE_p_Functions1D__DensityF1D swig_types[48]
+#define SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D swig_types[49]
+#define SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D swig_types[50]
+#define SWIGTYPE_p_Functions1D__GetOccludeeF1D swig_types[51]
+#define SWIGTYPE_p_Functions1D__GetOccludersF1D swig_types[52]
+#define SWIGTYPE_p_Functions1D__GetProjectedXF1D swig_types[53]
+#define SWIGTYPE_p_Functions1D__GetProjectedYF1D swig_types[54]
+#define SWIGTYPE_p_Functions1D__GetProjectedZF1D swig_types[55]
+#define SWIGTYPE_p_Functions1D__GetShapeF1D swig_types[56]
+#define SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D swig_types[57]
+#define SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D swig_types[58]
+#define SWIGTYPE_p_Functions1D__GetXF1D swig_types[59]
+#define SWIGTYPE_p_Functions1D__GetYF1D swig_types[60]
+#define SWIGTYPE_p_Functions1D__GetZF1D swig_types[61]
+#define SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D swig_types[62]
+#define SWIGTYPE_p_Functions1D__LocalAverageDepthF1D swig_types[63]
+#define SWIGTYPE_p_Functions1D__Normal2DF1D swig_types[64]
+#define SWIGTYPE_p_Functions1D__Orientation2DF1D swig_types[65]
+#define SWIGTYPE_p_Functions1D__Orientation3DF1D swig_types[66]
+#define SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D swig_types[67]
+#define SWIGTYPE_p_Functions1D__TimeStampF1D swig_types[68]
+#define SWIGTYPE_p_Functions1D__ZDiscontinuityF1D swig_types[69]
+#define SWIGTYPE_p_GrayImage swig_types[70]
+#define SWIGTYPE_p_I1DContainer swig_types[71]
+#define SWIGTYPE_p_Id swig_types[72]
+#define SWIGTYPE_p_IntegrationType swig_types[73]
+#define SWIGTYPE_p_Interface0D swig_types[74]
+#define SWIGTYPE_p_Interface0DIterator swig_types[75]
+#define SWIGTYPE_p_Interface0DIteratorNested swig_types[76]
+#define SWIGTYPE_p_Interface1D swig_types[77]
+#define SWIGTYPE_p_Material swig_types[78]
+#define SWIGTYPE_p_MediumType swig_types[79]
+#define SWIGTYPE_p_Module swig_types[80]
+#define SWIGTYPE_p_Noise swig_types[81]
+#define SWIGTYPE_p_NonTVertex swig_types[82]
+#define SWIGTYPE_p_OmissionShader swig_types[83]
+#define SWIGTYPE_p_Omitter swig_types[84]
+#define SWIGTYPE_p_Operators swig_types[85]
+#define SWIGTYPE_p_Point swig_types[86]
+#define SWIGTYPE_p_Polygon3r swig_types[87]
+#define SWIGTYPE_p_Predicates0D__FalseUP0D swig_types[88]
+#define SWIGTYPE_p_Predicates0D__TrueUP0D swig_types[89]
+#define SWIGTYPE_p_Predicates1D__ContourUP1D swig_types[90]
+#define SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D swig_types[91]
+#define SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D swig_types[92]
+#define SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D swig_types[93]
+#define SWIGTYPE_p_Predicates1D__ExternalContourUP1D swig_types[94]
+#define SWIGTYPE_p_Predicates1D__FalseBP1D swig_types[95]
+#define SWIGTYPE_p_Predicates1D__FalseUP1D swig_types[96]
+#define SWIGTYPE_p_Predicates1D__Length2DBP1D swig_types[97]
+#define SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D swig_types[98]
+#define SWIGTYPE_p_Predicates1D__SameShapeIdBP1D swig_types[99]
+#define SWIGTYPE_p_Predicates1D__ShapeUP1D swig_types[100]
+#define SWIGTYPE_p_Predicates1D__TrueBP1D swig_types[101]
+#define SWIGTYPE_p_Predicates1D__TrueUP1D swig_types[102]
+#define SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D swig_types[103]
+#define SWIGTYPE_p_RGBImage swig_types[104]
+#define SWIGTYPE_p_ReturnedValueType swig_types[105]
+#define SWIGTYPE_p_SShape swig_types[106]
+#define SWIGTYPE_p_SVertex swig_types[107]
+#define SWIGTYPE_p_SVertex__fedges_container__iterator swig_types[108]
+#define SWIGTYPE_p_Smoother swig_types[109]
+#define SWIGTYPE_p_SmoothingShader swig_types[110]
+#define SWIGTYPE_p_SpatialNoiseShader swig_types[111]
+#define SWIGTYPE_p_SteerableViewMap swig_types[112]
+#define SWIGTYPE_p_Stroke swig_types[113]
+#define SWIGTYPE_p_StrokeAttribute swig_types[114]
+#define SWIGTYPE_p_StrokeInternal__StrokeVertexIterator swig_types[115]
+#define SWIGTYPE_p_StrokeLayer swig_types[116]
+#define SWIGTYPE_p_StrokeRenderer swig_types[117]
+#define SWIGTYPE_p_StrokeShader swig_types[118]
+#define SWIGTYPE_p_StrokeShaders__BSplineShader swig_types[119]
+#define SWIGTYPE_p_StrokeShaders__BackboneStretcherShader swig_types[120]
+#define SWIGTYPE_p_StrokeShaders__BezierCurveShader swig_types[121]
+#define SWIGTYPE_p_StrokeShaders__CalligraphicColorShader swig_types[122]
+#define SWIGTYPE_p_StrokeShaders__ColorNoiseShader swig_types[123]
+#define SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader swig_types[124]
+#define SWIGTYPE_p_StrokeShaders__ConstantColorShader swig_types[125]
+#define SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader swig_types[126]
+#define SWIGTYPE_p_StrokeShaders__ConstantThicknessShader swig_types[127]
+#define SWIGTYPE_p_StrokeShaders__ConstrainedIncreasingThicknessShader swig_types[128]
+#define SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader swig_types[129]
+#define SWIGTYPE_p_StrokeShaders__GuidingLinesShader swig_types[130]
+#define SWIGTYPE_p_StrokeShaders__IncreasingColorShader swig_types[131]
+#define SWIGTYPE_p_StrokeShaders__IncreasingThicknessShader swig_types[132]
+#define SWIGTYPE_p_StrokeShaders__InflateShader swig_types[133]
+#define SWIGTYPE_p_StrokeShaders__LengthDependingThicknessShader swig_types[134]
+#define SWIGTYPE_p_StrokeShaders__MaterialColorShader swig_types[135]
+#define SWIGTYPE_p_StrokeShaders__PolygonalizationShader swig_types[136]
+#define SWIGTYPE_p_StrokeShaders__SamplingShader swig_types[137]
+#define SWIGTYPE_p_StrokeShaders__StrokeTextureShader swig_types[138]
+#define SWIGTYPE_p_StrokeShaders__TextureAssignerShader swig_types[139]
+#define SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader swig_types[140]
+#define SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader swig_types[141]
+#define SWIGTYPE_p_StrokeShaders__TipRemoverShader swig_types[142]
+#define SWIGTYPE_p_StrokeShaders__fstreamShader swig_types[143]
+#define SWIGTYPE_p_StrokeShaders__streamShader swig_types[144]
+#define SWIGTYPE_p_StrokeVertex swig_types[145]
+#define SWIGTYPE_p_Stroke__vertex_container__iterator swig_types[146]
+#define SWIGTYPE_p_Stroke__viewedge_container__const_iterator swig_types[147]
+#define SWIGTYPE_p_Stroke__viewedge_container__iterator swig_types[148]
+#define SWIGTYPE_p_StrokesContainer swig_types[149]
+#define SWIGTYPE_p_StyleModule swig_types[150]
+#define SWIGTYPE_p_TVertex swig_types[151]
+#define SWIGTYPE_p_UnaryFunction0DTId_t swig_types[152]
+#define SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t swig_types[153]
+#define SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t swig_types[154]
+#define SWIGTYPE_p_UnaryFunction0DTViewShape_p_t swig_types[155]
+#define SWIGTYPE_p_UnaryFunction0DTdouble_t swig_types[156]
+#define SWIGTYPE_p_UnaryFunction0DTfloat_t swig_types[157]
+#define SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t swig_types[158]
+#define SWIGTYPE_p_UnaryFunction0DTunsigned_int_t swig_types[159]
+#define SWIGTYPE_p_UnaryFunction0DTvoid_t swig_types[160]
+#define SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t swig_types[161]
+#define SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t swig_types[162]
+#define SWIGTYPE_p_UnaryFunction1DTdouble_t swig_types[163]
+#define SWIGTYPE_p_UnaryFunction1DTfloat_t swig_types[164]
+#define SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t swig_types[165]
+#define SWIGTYPE_p_UnaryFunction1DTunsigned_int_t swig_types[166]
+#define SWIGTYPE_p_UnaryFunction1DTvoid_t swig_types[167]
+#define SWIGTYPE_p_UnaryPredicate0D swig_types[168]
+#define SWIGTYPE_p_UnaryPredicate1D swig_types[169]
+#define SWIGTYPE_p_VecMat__HVec3Tdouble_t swig_types[170]
+#define SWIGTYPE_p_VecMat__HVec3Tfloat_t swig_types[171]
+#define SWIGTYPE_p_VecMat__HVec3Tint_t swig_types[172]
+#define SWIGTYPE_p_VecMat__HVec3Tunsigned_int_t swig_types[173]
+#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_2_t swig_types[174]
+#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_3_t swig_types[175]
+#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_4_t swig_types[176]
+#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_2_t swig_types[177]
+#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_3_t swig_types[178]
+#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_4_t swig_types[179]
+#define SWIGTYPE_p_VecMat__SquareMatrixTint_2_t swig_types[180]
+#define SWIGTYPE_p_VecMat__SquareMatrixTint_3_t swig_types[181]
+#define SWIGTYPE_p_VecMat__SquareMatrixTint_4_t swig_types[182]
+#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_2_t swig_types[183]
+#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_3_t swig_types[184]
+#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_4_t swig_types[185]
+#define SWIGTYPE_p_VecMat__Vec2Tdouble_t swig_types[186]
+#define SWIGTYPE_p_VecMat__Vec2Tfloat_t swig_types[187]
+#define SWIGTYPE_p_VecMat__Vec2Tint_t swig_types[188]
+#define SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t swig_types[189]
+#define SWIGTYPE_p_VecMat__Vec3Tdouble_t swig_types[190]
+#define SWIGTYPE_p_VecMat__Vec3Tfloat_t swig_types[191]
+#define SWIGTYPE_p_VecMat__Vec3Tint_t swig_types[192]
+#define SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t swig_types[193]
+#define SWIGTYPE_p_VecMat__VecTdouble_2_t swig_types[194]
+#define SWIGTYPE_p_VecMat__VecTdouble_3_t swig_types[195]
+#define SWIGTYPE_p_VecMat__VecTfloat_2_t swig_types[196]
+#define SWIGTYPE_p_VecMat__VecTfloat_3_t swig_types[197]
+#define SWIGTYPE_p_VecMat__VecTint_2_t swig_types[198]
+#define SWIGTYPE_p_VecMat__VecTint_3_t swig_types[199]
+#define SWIGTYPE_p_VecMat__VecTunsigned_int_2_t swig_types[200]
+#define SWIGTYPE_p_VecMat__VecTunsigned_int_3_t swig_types[201]
+#define SWIGTYPE_p_Vertex swig_types[202]
+#define SWIGTYPE_p_ViewEdge swig_types[203]
+#define SWIGTYPE_p_ViewEdgeInternal__SVertexIterator swig_types[204]
+#define SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator swig_types[205]
+#define SWIGTYPE_p_ViewMap swig_types[206]
+#define SWIGTYPE_p_ViewShape swig_types[207]
+#define SWIGTYPE_p_ViewVertex swig_types[208]
+#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t swig_types[209]
+#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t swig_types[210]
+#define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator swig_types[211]
+#define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator swig_types[212]
+#define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator swig_types[213]
+#define SWIGTYPE_p_allocator_type swig_types[214]
+#define SWIGTYPE_p_char swig_types[215]
+#define SWIGTYPE_p_const_edge_iterator swig_types[216]
+#define SWIGTYPE_p_const_fedge_iterator swig_types[217]
+#define SWIGTYPE_p_const_point_iterator swig_types[218]
+#define SWIGTYPE_p_const_reference swig_types[219]
+#define SWIGTYPE_p_const_vertex_iterator swig_types[220]
+#define SWIGTYPE_p_difference_type swig_types[221]
+#define SWIGTYPE_p_directedViewEdge swig_types[222]
+#define SWIGTYPE_p_double swig_types[223]
+#define SWIGTYPE_p_edge_iterator swig_types[224]
+#define SWIGTYPE_p_edge_pointers_container swig_types[225]
+#define SWIGTYPE_p_edges_container swig_types[226]
+#define SWIGTYPE_p_fedge_iterator swig_types[227]
+#define SWIGTYPE_p_fedges_container swig_types[228]
+#define SWIGTYPE_p_float swig_types[229]
+#define SWIGTYPE_p_id_to_index_map swig_types[230]
+#define SWIGTYPE_p_id_type swig_types[231]
+#define SWIGTYPE_p_int swig_types[232]
+#define SWIGTYPE_p_ltstr swig_types[233]
+#define SWIGTYPE_p_mapsMap swig_types[234]
+#define SWIGTYPE_p_occluder_container__const_iterator swig_types[235]
+#define SWIGTYPE_p_p_PyObject swig_types[236]
+#define SWIGTYPE_p_point_iterator swig_types[237]
+#define SWIGTYPE_p_point_type swig_types[238]
+#define SWIGTYPE_p_reference swig_types[239]
+#define SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t swig_types[240]
+#define SWIGTYPE_p_size_type swig_types[241]
+#define SWIGTYPE_p_std__invalid_argument swig_types[242]
+#define SWIGTYPE_p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t swig_types[243]
+#define SWIGTYPE_p_std__pairTViewEdge_p_bool_t swig_types[244]
+#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t swig_types[245]
+#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type swig_types[246]
+#define SWIGTYPE_p_std__vectorTMaterial_std__allocatorTMaterial_t_t swig_types[247]
+#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t swig_types[248]
+#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type swig_types[249]
+#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t swig_types[250]
+#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type swig_types[251]
+#define SWIGTYPE_p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t swig_types[252]
+#define SWIGTYPE_p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t swig_types[253]
+#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t swig_types[254]
+#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type swig_types[255]
+#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t swig_types[256]
+#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type swig_types[257]
+#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t swig_types[258]
+#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type swig_types[259]
+#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[260]
+#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[261]
+#define SWIGTYPE_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t swig_types[262]
+#define SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t swig_types[263]
+#define SWIGTYPE_p_svertices_container swig_types[264]
+#define SWIGTYPE_p_swig__PySwigIterator swig_types[265]
+#define SWIGTYPE_p_unsigned_int swig_types[266]
+#define SWIGTYPE_p_unsigned_short swig_types[267]
+#define SWIGTYPE_p_value_type swig_types[268]
+#define SWIGTYPE_p_vertex_container swig_types[269]
+#define SWIGTYPE_p_vertex_iterator swig_types[270]
+#define SWIGTYPE_p_vertex_type swig_types[271]
+#define SWIGTYPE_p_viewedge_container swig_types[272]
+#define SWIGTYPE_p_viewedges_container swig_types[273]
+#define SWIGTYPE_p_viewshapes_container swig_types[274]
+#define SWIGTYPE_p_viewvertices_container swig_types[275]
+#define SWIGTYPE_p_void swig_types[276]
+#define SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type swig_types[277]
+#define SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type swig_types[278]
+#define SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type swig_types[279]
+#define SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type swig_types[280]
+#define SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type swig_types[281]
+#define SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type swig_types[282]
+static swig_type_info *swig_types[284];
+static swig_module_info swig_module = {swig_types, 283, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#if (PY_VERSION_HEX <= 0x02000000)
+# if !defined(SWIG_PYTHON_CLASSIC)
+#  error "This python version requires swig to be run with the '-classic' option"
+# endif
+#endif
+
+/*-----------------------------------------------
+              @(target):= _Freestyle.so
+  ------------------------------------------------*/
+#define SWIG_init    init_Freestyle
+
+#define SWIG_name    "_Freestyle"
+
+#define SWIGVERSION 0x010331 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+namespace swig {
+  class PyObject_ptr {
+  protected:
+    PyObject *_obj;
+
+  public:
+    PyObject_ptr() :_obj(0)
+    {
+    }
+
+    PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
+    {
+      Py_XINCREF(_obj);      
+    }
+    
+    PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
+    {
+      if (initial_ref) Py_XINCREF(_obj);
+    }
+    
+    PyObject_ptr & operator=(const PyObject_ptr& item) 
+    {
+      Py_XINCREF(item._obj);
+      Py_XDECREF(_obj);
+      _obj = item._obj;
+      return *this;      
+    }
+    
+    ~PyObject_ptr() 
+    {
+      Py_XDECREF(_obj);
+    }
+    
+    operator PyObject *() const
+    {
+      return _obj;
+    }
+
+    PyObject *operator->() const
+    {
+      return _obj;
+    }
+  };
+}
+
+
+namespace swig {
+  struct PyObject_var : PyObject_ptr {
+    PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
+    
+    PyObject_var & operator = (PyObject* obj)
+    {
+      Py_XDECREF(_obj);
+      _obj = obj;
+      return *this;      
+    }
+  };
+}
+
+
+ #include "../system/Cast.h"
+ #include "../stroke/Module.h"
+ #include "../system/Precision.h"
+ #include "../system/Id.h"
+ #include "../geometry/VecMat.h"
+ #include "../geometry/Geom.h"
+ #include "../geometry/Noise.h"
+ #include "../scene_graph/Material.h"
+ #include "../winged_edge/Nature.h"
+ #include "../view_map/Interface0D.h"
+ #include "../view_map/Interface1D.h"
+ #include "../view_map/Functions0D.h"
+ #include "../view_map/Functions1D.h"
+ #include "../view_map/Silhouette.h"
+ #include "../view_map/ViewMap.h"
+ #include "../view_map/ViewMapIterators.h"
+ #include "../stroke/AdvancedFunctions0D.h"
+ #include "../stroke/AdvancedFunctions1D.h"
+ #include "../stroke/ChainingIterators.h"
+ #include "../stroke/ContextFunctions.h"
+ #include "../stroke/Predicates0D.h"
+ #include "../stroke/Predicates1D.h"
+ #include "../stroke/AdvancedPredicates1D.h"
+ #include "../stroke/StrokeShader.h"
+// #include "../stroke/Curve.h"
+ #include "../stroke/CurveIterators.h"       
+ #include "../stroke/Stroke.h"
+ #include "../stroke/StrokeIterators.h"
+ #include "../stroke/BasicStrokeShaders.h"
+ #include "../stroke/AdvancedStrokeShaders.h"
+ #include "../stroke/Operators.h"
+ #include "../stroke/Canvas.h"
+
+
+#include <stdexcept>
+
+
+  
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
+#  define SWIG_STD_NOASSIGN_STL
+#  define SWIG_STD_NOINSERT_TEMPLATE_STL
+#  define SWIG_STD_NOITERATOR_TRAITS_STL
+#endif
+
+#if defined(__GNUC__)
+#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
+#     define SWIG_STD_NOMODERN_STL
+#  endif
+#endif
+
+
+
+
+#include <string>
+#include <stdexcept>
+
+
+#include <string>
+
+
+#include <iostream>
+
+  
+namespace swig {
+  struct stop_iteration {
+  };
+
+  struct PySwigIterator {
+  private:
+    PyObject_ptr _seq;
+
+  protected:
+    PySwigIterator(PyObject *seq) : _seq(seq)
+    {
+    }
+      
+  public:
+    virtual ~PySwigIterator() {}
+
+    // Access iterator method, required by Python
+    virtual PyObject *value() const = 0;
+
+    // Forward iterator method, required by Python
+    virtual PySwigIterator *incr(size_t n = 1) = 0;
+    
+    // Backward iterator method, very common in C++, but not required in Python
+    virtual PySwigIterator *decr(size_t n = 1)
+    {
+      throw stop_iteration();
+    }
+
+    // Random access iterator methods, but not required in Python
+    virtual ptrdiff_t distance(const PySwigIterator &x) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+
+    virtual bool equal (const PySwigIterator &x) const
+    {
+      throw std::invalid_argument("operation not supported");
+    }
+    
+    // C++ common/needed methods
+    virtual PySwigIterator *copy() const = 0;
+
+    PyObject *next()
+    {
+      PyObject *obj = value();
+      incr();
+      return obj;
+    }
+
+    PyObject *previous()
+    {
+      decr();
+      return value();
+    }
+
+    PySwigIterator *advance(ptrdiff_t n)
+    {
+      return  (n > 0) ?  incr(n) : decr(-n);
+    }
+      
+    bool operator == (const PySwigIterator& x)  const
+    {
+      return equal(x);
+    }
+      
+    bool operator != (const PySwigIterator& x) const
+    {
+      return ! operator==(x);
+    }
+      
+    PySwigIterator& operator += (ptrdiff_t n)
+    {
+      return *advance(n);
+    }
+
+    PySwigIterator& operator -= (ptrdiff_t n)
+    {
+      return *advance(-n);
+    }
+      
+    PySwigIterator* operator + (ptrdiff_t n) const
+    {
+      return copy()->advance(n);
+    }
+
+    PySwigIterator* operator - (ptrdiff_t n) const
+    {
+      return copy()->advance(-n);
+    }
+      
+    ptrdiff_t operator - (const PySwigIterator& x) const
+    {
+      return x.distance(*this);
+    }
+      
+    static swig_type_info* descriptor() {
+      static int init = 0;
+      static swig_type_info* desc = 0;
+      if (!init) {
+	desc = SWIG_TypeQuery("swig::PySwigIterator *");
+	init = 1;
+      }	
+      return desc;
+    }    
+  };
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_double (PyObject *obj, double *val)
+{
+  int res = SWIG_TypeError;
+  if (PyFloat_Check(obj)) {
+    if (val) *val = PyFloat_AsDouble(obj);
+    return SWIG_OK;
+  } else if (PyInt_Check(obj)) {
+    if (val) *val = PyInt_AsLong(obj);
+    return SWIG_OK;
+  } else if (PyLong_Check(obj)) {
+    double v = PyLong_AsDouble(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+    }
+  }
+#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    double d = PyFloat_AsDouble(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = d;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      long v = PyLong_AsLong(obj);
+      if (!PyErr_Occurred()) {
+	if (val) *val = v;
+	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
+      } else {
+	PyErr_Clear();
+      }
+    }
+  }
+#endif
+  return res;
+}
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+SWIGINTERNINLINE int
+SWIG_CanCastAsInteger(double *d, double min, double max) {
+  double x = *d;
+  if ((min <= x && x <= max)) {
+   double fx = floor(x);
+   double cx = ceil(x);
+   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
+   if ((errno == EDOM) || (errno == ERANGE)) {
+     errno = 0;
+   } else {
+     double summ, reps, diff;
+     if (rd < x) {
+       diff = x - rd;
+     } else if (rd > x) {
+       diff = rd - x;
+     } else {
+       return 1;
+     }
+     summ = rd + x;
+     reps = diff/summ;
+     if (reps < 8*DBL_EPSILON) {
+       *d = rd;
+       return 1;
+     }
+   }
+  }
+  return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
+{
+  if (PyInt_Check(obj)) {
+    long v = PyInt_AsLong(obj);
+    if (v >= 0) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }
+  } else if (PyLong_Check(obj)) {
+    unsigned long v = PyLong_AsUnsignedLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+    }
+  }
+#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    unsigned long v = PyLong_AsUnsignedLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+	if (val) *val = (unsigned long)(d);
+	return res;
+      }
+    }
+  }
+#endif
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t (PyObject * obj, size_t *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
+  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
+  return res;
+}
+
+
+  #define SWIG_From_long   PyInt_FromLong 
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_ptrdiff_t  (ptrdiff_t value)
+{    
+  return SWIG_From_long  (static_cast< long >(value));
+}
+
+
+SWIGINTERNINLINE PyObject*
+  SWIG_From_bool  (bool value)
+{
+  return PyBool_FromLong(value ? 1 : 0);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_long (PyObject *obj, long* val)
+{
+  if (PyInt_Check(obj)) {
+    if (val) *val = PyInt_AsLong(obj);
+    return SWIG_OK;
+  } else if (PyLong_Check(obj)) {
+    long v = PyLong_AsLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      PyErr_Clear();
+    }
+  }
+#ifdef SWIG_PYTHON_CAST_MODE
+  {
+    int dispatch = 0;
+    long v = PyInt_AsLong(obj);
+    if (!PyErr_Occurred()) {
+      if (val) *val = v;
+      return SWIG_AddCast(SWIG_OK);
+    } else {
+      PyErr_Clear();
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
+	if (val) *val = (long)(d);
+	return res;
+      }
+    }
+  }
+#endif
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, val ? &v : 0);
+  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
+  return res;
+}
+
+
+#include <stdexcept>
+
+
+#include <algorithm>
+
+
+#include <vector>
+
+
+#include <utility>
+
+
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+
+
+namespace swig {  
+  template <class Type>
+  struct noconst_traits {
+    typedef Type noconst_type;
+  };
+
+  template <class Type>
+  struct noconst_traits<const Type> {
+    typedef Type noconst_type;
+  };
+
+  /*
+    type categories
+  */
+  struct pointer_category { };  
+  struct value_category { };
+
+  /*
+    General traits that provides type_name and type_info
+  */
+  template <class Type> struct traits { };
+
+  template <class Type>
+  inline const char* type_name() {
+    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
+  }
+
+  template <class Type> 
+  struct traits_info {
+    static swig_type_info *type_query(std::string name) {
+      name += " *";
+      return SWIG_TypeQuery(name.c_str());
+    }    
+    static swig_type_info *type_info() {
+      static swig_type_info *info = type_query(type_name<Type>());
+      return info;
+    }
+  };
+
+  template <class Type>
+  inline swig_type_info *type_info() {
+    return traits_info<Type>::type_info();
+  }
+
+  /*
+    Partial specialization for pointers
+  */
+  template <class Type> struct traits <Type *> {
+    typedef pointer_category category;
+    static std::string make_ptr_name(const char* name) {
+      std::string ptrname = name;
+      ptrname += " *";
+      return ptrname;
+    }    
+    static const char* type_name() {
+      static std::string name = make_ptr_name(swig::type_name<Type>());
+      return name.c_str();
+    }
+  };
+
+  template <class Type, class Category> 
+  struct traits_as { };
+ 
+  template <class Type, class Category> 
+  struct traits_check { };
+
+}
+
+
+namespace swig {  
+  /*
+    Traits that provides the from method
+  */
+  template <class Type> struct traits_from_ptr {
+    static PyObject *from(Type *val, int owner = 0) {
+      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
+    }
+  };
+
+  template <class Type> struct traits_from {
+    static PyObject *from(const Type& val) {
+      return traits_from_ptr<Type>::from(new Type(val), 1);
+    }
+  };
+
+  template <class Type> struct traits_from<Type *> {
+    static PyObject *from(Type* val) {
+      return traits_from_ptr<Type>::from(val, 0);
+    }
+  };
+
+  template <class Type> struct traits_from<const Type *> {
+    static PyObject *from(const Type* val) {
+      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
+    }
+  };
+
+
+  template <class Type>
+  inline PyObject *from(const Type& val) {
+    return traits_from<Type>::from(val);
+  }
+
+  template <class Type>
+  inline PyObject *from_ptr(Type* val, int owner) {
+    return traits_from_ptr<Type>::from(val, owner);
+  }
+
+  /*
+    Traits that provides the asval/as/check method
+  */
+  template <class Type>
+  struct traits_asptr {   
+    static int asptr(PyObject *obj, Type **val) {
+      Type *p;
+      int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
+      if (SWIG_IsOK(res)) {
+	if (val) *val = p;
+      }
+      return res;
+    }
+  }; 
+
+  template <class Type>
+  inline int asptr(PyObject *obj, Type **vptr) {
+    return traits_asptr<Type>::asptr(obj, vptr);
+  }
+
+  template <class Type> 
+  struct traits_asval {
+    static int asval(PyObject *obj, Type *val) {
+      if (val) {
+	Type *p = 0;
+	int res = traits_asptr<Type>::asptr(obj, &p);
+	if (!SWIG_IsOK(res)) return res;	
+	if (p) {
+	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
+	  *(const_cast<noconst_type*>(val)) = *p;
+	  if (SWIG_IsNewObj(res)){
+	    delete p;
+	    res = SWIG_DelNewMask(res);
+	  }
+	  return res;
+	} else {
+	  return SWIG_ERROR;
+	}
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+
+  template <class Type> struct traits_asval<Type*> {
+    static int asval(PyObject *obj, Type **val) {
+      if (val) {
+        typedef typename noconst_traits<Type>::noconst_type noconst_type;
+        noconst_type *p = 0;
+        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
+        if (SWIG_IsOK(res)) {
+          *(const_cast<noconst_type**>(val)) = p;
+	}
+	return res;
+      } else {
+	return traits_asptr<Type>::asptr(obj, (Type **)(0));
+      }
+    }
+  };
+  
+  template <class Type>
+  inline int asval(PyObject *obj, Type *val) {
+    return traits_asval<Type>::asval(obj, val);
+  }
+
+  template <class Type> 
+  struct traits_as<Type, value_category> {
+    static Type as(PyObject *obj, bool throw_error) {
+      Type v;
+      int res = asval(obj, &v);
+      if (!obj || !SWIG_IsOK(res)) {
+	if (!PyErr_Occurred()) {
+	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+      }
+      return v;
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type, pointer_category> {
+    static Type as(PyObject *obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res) && v) {
+	if (SWIG_IsNewObj(res)) {
+	  Type r(*v);
+	  delete v;
+	  return r;
+	} else {
+	  return *v;
+	}
+      } else {
+	// Uninitialized return value, no Type() constructor required.
+	static Type *v_def = (Type*) malloc(sizeof(Type));
+	if (!PyErr_Occurred()) {
+	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	memset(v_def,0,sizeof(Type));
+	return *v_def;
+      }
+    }
+  };
+
+  template <class Type> 
+  struct traits_as<Type*, pointer_category> {
+    static Type* as(PyObject *obj, bool throw_error) {
+      Type *v = 0;      
+      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
+      if (SWIG_IsOK(res)) {
+	return v;
+      } else {
+	if (!PyErr_Occurred()) {
+	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
+	}
+	if (throw_error) throw std::invalid_argument("bad type");
+	return 0;
+      }
+    }
+  };
+    
+  template <class Type>
+  inline Type as(PyObject *obj, bool te = false) {
+    return traits_as<Type, typename traits<Type>::category>::as(obj, te);
+  }
+
+  template <class Type> 
+  struct traits_check<Type, value_category> {
+    static bool check(PyObject *obj) {
+      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type> 
+  struct traits_check<Type, pointer_category> {
+    static bool check(PyObject *obj) {
+      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
+      return SWIG_IsOK(res) ? true : false;
+    }
+  };
+
+  template <class Type>
+  inline bool check(PyObject *obj) {
+    return traits_check<Type, typename traits<Type>::category>::check(obj);
+  }
+}
+
+
+#include <functional>
+
+namespace std {
+  template <>
+  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
+  {
+    bool
+    operator()(PyObject * v, PyObject *w) const
+    { 
+      bool res;
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+      res = PyObject_Compare(v, w) < 0;
+      SWIG_PYTHON_THREAD_END_BLOCK;
+      return res;
+    }
+  };
+
+  template <>
+  struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
+  {
+    bool
+    operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
+    {
+      return std::less<PyObject *>()(v, w);
+    }
+  };
+
+  template <>
+  struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
+  {
+    bool
+    operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
+    {
+      return std::less<PyObject *>()(v, w);
+    }
+  };
+
+}
+
+namespace swig {
+  template <> struct traits<PyObject *> {
+    typedef value_category category;
+    static const char* type_name() { return "PyObject *"; }
+  };  
+
+  template <>  struct traits_asval<PyObject * > {   
+    typedef PyObject * value_type;
+    static int asval(PyObject *obj, value_type *val) {
+      if (val) *val = obj;
+      return SWIG_OK;
+    }
+  };
+
+  template <> 
+  struct traits_check<PyObject *, value_category> {
+    static bool check(PyObject *) {
+      return true;
+    }
+  };
+
+  template <>  struct traits_from<PyObject *> {
+    typedef PyObject * value_type;
+    static PyObject *from(const value_type& val) {
+      Py_XINCREF(val);
+      return val;
+    }
+  };
+  
+}
+
+namespace swig {
+  inline size_t
+  check_index(ptrdiff_t i, size_t size, bool insert = false) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size)
+	return (size_t) (i + size);
+    } else if ( (size_t) i < size ) {
+      return (size_t) i;
+    } else if (insert && ((size_t) i == size)) {
+      return size;
+    }
+    
+    throw std::out_of_range("index out of range");
+  }
+
+  inline size_t
+  slice_index(ptrdiff_t i, size_t size) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size) {
+	return (size_t) (i + size);
+      } else {
+	throw std::out_of_range("index out of range");
+      }
+    } else {
+      return ( (size_t) i < size ) ? ((size_t) i) : size;
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::iterator
+  getpos(Sequence* self, Difference i)  {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline typename Sequence::const_iterator
+  cgetpos(const Sequence* self, Difference i)  {
+    typename Sequence::const_iterator pos = self->begin();
+    std::advance(pos, check_index(i,self->size()));
+    return pos;
+  }
+
+  template <class Sequence, class Difference>
+  inline Sequence*
+  getslice(const Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+
+    if (jj > ii) {
+      typename Sequence::const_iterator vb = self->begin();
+      typename Sequence::const_iterator ve = self->begin();
+      std::advance(vb,ii);
+      std::advance(ve,jj);
+      return new Sequence(vb, ve);
+    } else {
+      return new Sequence();
+    }
+  }
+
+  template <class Sequence, class Difference, class InputSeq>
+  inline void
+  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj < ii) jj = ii;
+    size_t ssize = jj - ii;
+    if (ssize <= v.size()) {
+      typename Sequence::iterator sb = self->begin();
+      typename InputSeq::const_iterator vmid = v.begin();
+      std::advance(sb,ii);
+      std::advance(vmid, jj - ii);
+      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
+    } else {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+      self->insert(sb, v.begin(), v.end());
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline void
+  delslice(Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swig::check_index(i, size, true);
+    typename Sequence::size_type jj = swig::slice_index(j, size);
+    if (jj > ii) {
+      typename Sequence::iterator sb = self->begin();
+      typename Sequence::iterator se = self->begin();
+      std::advance(sb,ii);
+      std::advance(se,jj);
+      self->erase(sb,se);
+    }
+  }
+}
+
+
+#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
+#include <iterator>
+#else
+namespace std  {
+  template <class Iterator>
+  struct iterator_traits {
+    typedef ptrdiff_t difference_type;
+    typedef typename Iterator::value_type value_type;
+  };
+
+#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
+  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
+  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
+    typedef Distance difference_type;
+    typedef T value_type;
+  };
+#endif  
+
+  template <class T>
+  struct iterator_traits<T*> {
+    typedef T value_type;
+    typedef ptrdiff_t difference_type;
+  };
+
+  template<typename _InputIterator>
+  inline typename iterator_traits<_InputIterator>::difference_type
+  distance(_InputIterator __first, _InputIterator __last)
+  {
+    typename iterator_traits<_InputIterator>::difference_type __n = 0;
+    while (__first != __last) {
+      ++__first; ++__n;
+    }
+    return __n;
+  }
+
+} 
+#endif
+
+
+namespace swig {
+  template<typename OutIterator>
+  class PySwigIterator_T :  public PySwigIterator
+  {
+  public:
+    typedef OutIterator out_iterator;
+    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
+    typedef PySwigIterator_T<out_iterator> self_type;
+
+    PySwigIterator_T(out_iterator curr, PyObject *seq)
+      : PySwigIterator(seq), current(curr)
+    {
+    }
+
+    const out_iterator& get_current() const
+    {
+      return current;
+    }
+
+    
+    bool equal (const PySwigIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return (current == iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }
+    
+    ptrdiff_t distance(const PySwigIterator &iter) const
+    {
+      const self_type *iters = dynamic_cast<const self_type *>(&iter);
+      if (iters) {
+	return std::distance(current, iters->get_current());
+      } else {
+	throw std::invalid_argument("bad iterator type");
+      }
+    }    
+    
+  protected:
+    out_iterator current;
+  };
+  
+  template <class ValueType>
+  struct from_oper 
+  {
+    typedef const ValueType& argument_type;
+    typedef PyObject *result_type;
+    result_type operator()(argument_type v) const
+    {
+      return swig::from(v);
+    }
+  };
+
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef PySwigIterator_T<out_iterator>  base;
+    typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
+    
+    PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
+      : PySwigIterator_T<OutIterator>(curr, seq)
+    {
+    }
+    
+    PyObject *value() const {
+      return from(static_cast<const value_type&>(*(base::current)));
+    }
+    
+    PySwigIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    PySwigIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	++base::current;
+      }
+      return this;
+    }
+
+    PySwigIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	--base::current;
+      }
+      return this;
+    }
+  };
+
+  template<typename OutIterator, 
+	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
+	   typename FromOper = from_oper<ValueType> >
+  class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
+  {
+  public:
+    FromOper from;
+    typedef OutIterator out_iterator;
+    typedef ValueType value_type;
+    typedef PySwigIterator_T<out_iterator>  base;    
+    typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
+    
+    PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
+      : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
+    {
+    }
+    
+    PyObject *value() const {
+      if (base::current == end) {
+	throw stop_iteration();
+      } else {
+	return from(static_cast<const value_type&>(*(base::current)));
+      }
+    }
+    
+    PySwigIterator *copy() const
+    {
+      return new self_type(*this);
+    }
+
+    PySwigIterator *incr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == end) {
+	  throw stop_iteration();
+	} else {
+	  ++base::current;
+	}
+      }
+      return this;
+    }
+
+    PySwigIterator *decr(size_t n = 1)
+    {
+      while (n--) {
+	if (base::current == begin) {
+	  throw stop_iteration();
+	} else {
+	  --base::current;
+	}
+      }
+      return this;
+    }
+
+  private:
+    out_iterator begin;
+    out_iterator end;
+  };
+
+  template<typename OutIter>
+  inline PySwigIterator*
+  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
+  {
+    return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
+  }
+
+  template<typename OutIter>
+  inline PySwigIterator*
+  make_output_iterator(const OutIter& current, PyObject *seq = 0)
+  {
+    return new PySwigIteratorOpen_T<OutIter>(current, seq);
+  }
+}
+
+
+namespace swig
+{
+  template <class T>
+  struct PySequence_Ref
+  {
+    PySequence_Ref(PyObject* seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+    
+    operator T () const
+    {
+      swig::PyObject_var item = PySequence_GetItem(_seq, _index);
+      try {
+	return swig::as<T>(item, true);
+      } catch (std::exception& e) {
+	char msg[1024];
+	sprintf(msg, "in sequence element %d ", _index);
+	if (!PyErr_Occurred()) {
+	  SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
+	}
+	SWIG_Python_AddErrorMsg(msg);
+	SWIG_Python_AddErrorMsg(e.what());
+	throw;
+      }
+    }
+
+    PySequence_Ref& operator=(const T& v)
+    {
+      PySequence_SetItem(_seq, _index, swig::from<T>(v));
+      return *this;
+    }
+
+  private:
+    PyObject* _seq;
+    int _index;
+  };
+
+  template <class T>
+  struct PySequence_ArrowProxy
+  {
+    PySequence_ArrowProxy(const T& x): m_value(x) {}
+    const T* operator->() const { return &m_value; }
+    operator const T*() const { return &m_value; }
+    T m_value;
+  };
+
+  template <class T, class Reference >
+  struct PySequence_InputIterator
+  {
+    typedef PySequence_InputIterator<T, Reference > self;
+
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef Reference reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+
+    PySequence_InputIterator()
+    {
+    }
+
+    PySequence_InputIterator(PyObject* seq, int index)
+      : _seq(seq), _index(index)
+    {
+    }
+
+    reference operator*() const
+    {
+      return reference(_seq, _index);
+    }
+
+    PySequence_ArrowProxy<T>
+    operator->() const {
+      return PySequence_ArrowProxy<T>(operator*());
+    }
+
+    bool operator==(const self& ri) const
+    {
+      return (_index == ri._index) && (_seq == ri._seq);
+    }
+
+    bool operator!=(const self& ri) const
+    {
+      return !(operator==(ri));
+    }
+
+    self& operator ++ ()
+    {
+      ++_index;
+      return *this;
+    }
+
+    self& operator -- ()
+    {
+      --_index;
+      return *this;
+    }
+
+    self& operator += (difference_type n)
+    {
+      _index += n;
+      return *this;
+    }
+
+    self operator +(difference_type n) const
+    {
+      return self(_seq, _index + n);
+    }
+
+    self& operator -= (difference_type n)
+    {
+      _index -= n;
+      return *this;
+    }
+
+    self operator -(difference_type n) const
+    {
+      return self(_seq, _index - n);
+    }
+
+    difference_type operator - (const self& ri) const
+    {
+      return _index - ri._index;
+    }
+
+    bool operator < (const self& ri) const
+    {
+      return _index < ri._index;
+    }
+
+    reference
+    operator[](difference_type n) const
+    {
+      return reference(_seq, _index + n);
+    }
+
+  private:
+    PyObject* _seq;
+    difference_type _index;
+  };
+
+  template <class T>
+  struct PySequence_Cont
+  {
+    typedef PySequence_Ref<T> reference;
+    typedef const PySequence_Ref<T> const_reference;
+    typedef T value_type;
+    typedef T* pointer;
+    typedef int difference_type;
+    typedef int size_type;
+    typedef const pointer const_pointer;
+    typedef PySequence_InputIterator<T, reference> iterator;
+    typedef PySequence_InputIterator<T, const_reference> const_iterator;
+
+    PySequence_Cont(PyObject* seq) : _seq(0)
+    {
+      if (!PySequence_Check(seq)) {
+	throw std::invalid_argument("a sequence is expected");
+      }
+      _seq = seq;
+      Py_INCREF(_seq);
+    }
+
+    ~PySequence_Cont()
+    {
+      if (_seq) Py_DECREF(_seq);
+    }
+
+    size_type size() const
+    {
+      return PySequence_Size(_seq);
+    }
+
+    bool empty() const
+    {
+      return size() == 0;
+    }
+
+    iterator begin()
+    {
+      return iterator(_seq, 0);
+    }
+
+    const_iterator begin() const
+    {
+      return const_iterator(_seq, 0);
+    }
+
+    iterator end()
+    {
+      return iterator(_seq, size());
+    }
+
+    const_iterator end() const
+    {
+      return const_iterator(_seq, size());
+    }
+
+    reference operator[](difference_type n)
+    {
+      return reference(_seq, n);
+    }
+
+    const_reference operator[](difference_type n)  const
+    {
+      return const_reference(_seq, n);
+    }
+
+    bool check(bool set_err = true) const
+    {
+      int s = size();
+      for (int i = 0; i < s; ++i) {
+	swig::PyObject_var item = PySequence_GetItem(_seq, i);
+	if (!swig::check<value_type>(item)) {
+	  if (set_err) {
+	    char msg[1024];
+	    sprintf(msg, "in sequence element %d", i);
+	    SWIG_Error(SWIG_RuntimeError, msg);
+	  }
+	  return false;
+	}
+      }
+      return true;
+    }
+
+  private:
+    PyObject* _seq;
+  };
+
+}
+
+
+#include <limits.h>
+#ifndef LLONG_MIN
+# define LLONG_MIN	LONG_LONG_MIN
+#endif
+#ifndef LLONG_MAX
+# define LLONG_MAX	LONG_LONG_MAX
+#endif
+#ifndef ULLONG_MAX
+# define ULLONG_MAX	ULONG_LONG_MAX
+#endif
+
+
+SWIGINTERN int
+SWIG_AsVal_int (PyObject * obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
+namespace swig {
+  template <> struct traits<int > {
+    typedef value_category category;
+    static const char* type_name() { return"int"; }
+  };  
+  template <>  struct traits_asval<int > {   
+    typedef int value_type;
+    static int asval(PyObject *obj, value_type *val) { 
+      return SWIG_AsVal_int (obj, val);
+    }
+  };
+  template <>  struct traits_from<int > {
+    typedef int value_type;
+    static PyObject *from(const value_type& val) {
+      return SWIG_From_int  (val);
+    }
+  };
+}
+
+
+namespace swig {
+  template <class PySeq, class Seq>
+  inline void
+  assign(const PySeq& pyseq, Seq* seq) {
+#ifdef SWIG_STD_NOASSIGN_STL
+    typedef typename PySeq::value_type value_type;
+    typename PySeq::const_iterator it = pyseq.begin();
+    for (;it != pyseq.end(); ++it) {
+      seq->insert(seq->end(),(value_type)(*it));
+    }
+#else
+    seq->assign(pyseq.begin(), pyseq.end());
+#endif
+  }
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_asptr_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+
+    static int asptr(PyObject *obj, sequence **seq) {
+      if (PySequence_Check(obj)) {
+	try {
+	  PySequence_Cont<value_type> pyseq(obj);
+	  if (seq) {
+	    sequence *pseq = new sequence();
+	    assign(pyseq, pseq);
+	    *seq = pseq;
+	    return SWIG_NEWOBJ;
+	  } else {
+	    return pyseq.check() ? SWIG_OK : SWIG_ERROR;
+	  }
+	} catch (std::exception& e) {
+	  if (seq) {
+	    if (!PyErr_Occurred()) {
+	      PyErr_SetString(PyExc_TypeError, e.what());
+	    }
+	  }
+	  return SWIG_ERROR;
+	}
+      } else {
+	sequence *p;
+	if (SWIG_ConvertPtr(obj,(void**)&p,
+			    swig::type_info<sequence>(),0) == SWIG_OK) {
+	  if (seq) *seq = p;
+	  return SWIG_OLDOBJ;
+	}
+      }
+      return SWIG_ERROR;
+    }
+  };
+
+  template <class Seq, class T = typename Seq::value_type >
+  struct traits_from_stdseq {
+    typedef Seq sequence;
+    typedef T value_type;
+    typedef typename Seq::size_type size_type;
+    typedef typename sequence::const_iterator const_iterator;
+
+    static PyObject *from(const sequence& seq) {
+
+
+
+
+
+
+      size_type size = seq.size();
+      if (size <= (size_type)INT_MAX) {
+	PyObject *obj = PyTuple_New((int)size);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
+	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
+	}
+	return obj;
+      } else {
+	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
+	return NULL;
+      }
+    }
+  };
+}
+
+
+  namespace swig {
+    template <class T>
+    struct traits_asptr<std::vector<T> >  {
+      static int asptr(PyObject *obj, std::vector<T> **vec) {
+	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
+      }
+    };
+    
+    template <class T>
+    struct traits_from<std::vector<T> > {
+      static PyObject *from(const std::vector<T>& vec) {
+	return traits_from_stdseq<std::vector<T> >::from(vec);
+      }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<int, std::allocator<int > > > {
+	  typedef pointer_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "int" "," "std::allocator<int >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector<int > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector<int > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<int >::size_type std_vector_Sl_int_Sg____len__(std::vector<int > const *self){
+      return self->size();
+    }
+
+SWIGINTERNINLINE PyObject* 
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return (value > LONG_MAX) ?
+    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value)); 
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_size_t  (size_t value)
+{    
+  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
+}
+
+SWIGINTERN std::vector<int >::value_type std_vector_Sl_int_Sg__pop(std::vector<int > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<int,std::allocator<int > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<int,std::allocator<int > > *std_vector_Sl_int_Sg____getslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j,std::vector<int,std::allocator<int > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector<int > *self,std::vector<int >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector<int > const *self,std::vector<int >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::value_type const &x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector<int > *self,std::vector<int >::value_type const &x){
+      self->push_back(x);
+    }
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+  #define SWIG_From_double   PyFloat_FromDouble 
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_float  (float value)
+{    
+  return SWIG_From_double  (value);
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_float (PyObject * obj, float *val)
+{
+  double v;
+  int res = SWIG_AsVal_double (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < -FLT_MAX || v > FLT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< float >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_unsigned_SS_short  (unsigned short value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
+    } else {
+      return PyString_FromStringAndSize(carray, static_cast< int >(size));
+    }
+  } else {
+    return SWIG_Py_Void();
+  }
+}
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_std_string  (const std::string& s)
+{
+  if (s.size()) {
+    return SWIG_FromCharPtrAndSize(s.data(), s.size());
+  } else {
+    return SWIG_FromCharPtrAndSize(s.c_str(), 0);
+  }
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > USHRT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned short >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (PyObject *obj, bool *val)
+{
+  if (obj == Py_True) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Py_False) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    long v = 0;
+    int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
+    if (SWIG_IsOK(res) && val) *val = v ? true : false;
+    return res;
+  }
+}
+
+
+  namespace swig {
+    template <>  struct traits<ViewShape > {
+      typedef pointer_category category;
+      static const char* type_name() { return"ViewShape"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<ViewShape*, std::allocator<ViewShape * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "ViewShape" " *," "std::allocator<ViewShape * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewShape_Sm__Sg__iterator(std::vector<ViewShape * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_ViewShape_Sm__Sg____nonzero__(std::vector<ViewShape * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<ViewShape * >::size_type std_vector_Sl_ViewShape_Sm__Sg____len__(std::vector<ViewShape * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg__pop(std::vector<ViewShape * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<ViewShape*,std::allocator<ViewShape * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<ViewShape *,std::allocator<ViewShape * > > *std_vector_Sl_ViewShape_Sm__Sg____getslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j,std::vector<ViewShape *,std::allocator<ViewShape * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg____getitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg__append(std::vector<ViewShape * > *self,std::vector<ViewShape * >::value_type x){
+      self->push_back(x);
+    }
+
+  namespace swig {
+    template <>  struct traits<ViewEdge > {
+      typedef pointer_category category;
+      static const char* type_name() { return"ViewEdge"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<ViewEdge*, std::allocator<ViewEdge * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "ViewEdge" " *," "std::allocator<ViewEdge * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewEdge_Sm__Sg__iterator(std::vector<ViewEdge * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_ViewEdge_Sm__Sg____nonzero__(std::vector<ViewEdge * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<ViewEdge * >::size_type std_vector_Sl_ViewEdge_Sm__Sg____len__(std::vector<ViewEdge * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg__pop(std::vector<ViewEdge * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<ViewEdge*,std::allocator<ViewEdge * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<ViewEdge *,std::allocator<ViewEdge * > > *std_vector_Sl_ViewEdge_Sm__Sg____getslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j,std::vector<ViewEdge *,std::allocator<ViewEdge * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg____getitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg__append(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::value_type x){
+      self->push_back(x);
+    }
+
+  namespace swig {
+    template <>  struct traits<FEdge > {
+      typedef pointer_category category;
+      static const char* type_name() { return"FEdge"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<FEdge*, std::allocator<FEdge * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "FEdge" " *," "std::allocator<FEdge * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_FEdge_Sm__Sg__iterator(std::vector<FEdge * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_FEdge_Sm__Sg____nonzero__(std::vector<FEdge * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<FEdge * >::size_type std_vector_Sl_FEdge_Sm__Sg____len__(std::vector<FEdge * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg__pop(std::vector<FEdge * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<FEdge*,std::allocator<FEdge * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<FEdge *,std::allocator<FEdge * > > *std_vector_Sl_FEdge_Sm__Sg____getslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j,std::vector<FEdge *,std::allocator<FEdge * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg____getitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg__append(std::vector<FEdge * > *self,std::vector<FEdge * >::value_type x){
+      self->push_back(x);
+    }
+
+  namespace swig {
+    template <>  struct traits<ViewVertex > {
+      typedef pointer_category category;
+      static const char* type_name() { return"ViewVertex"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<ViewVertex*, std::allocator<ViewVertex * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "ViewVertex" " *," "std::allocator<ViewVertex * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewVertex_Sm__Sg__iterator(std::vector<ViewVertex * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_ViewVertex_Sm__Sg____nonzero__(std::vector<ViewVertex * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<ViewVertex * >::size_type std_vector_Sl_ViewVertex_Sm__Sg____len__(std::vector<ViewVertex * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg__pop(std::vector<ViewVertex * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<ViewVertex*,std::allocator<ViewVertex * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<ViewVertex *,std::allocator<ViewVertex * > > *std_vector_Sl_ViewVertex_Sm__Sg____getslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j,std::vector<ViewVertex *,std::allocator<ViewVertex * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg____getitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg__append(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::value_type x){
+      self->push_back(x);
+    }
+
+  namespace swig {
+    template <>  struct traits<SVertex > {
+      typedef pointer_category category;
+      static const char* type_name() { return"SVertex"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<SVertex*, std::allocator<SVertex * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "SVertex" " *," "std::allocator<SVertex * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_SVertex_Sm__Sg__iterator(std::vector<SVertex * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_SVertex_Sm__Sg____nonzero__(std::vector<SVertex * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<SVertex * >::size_type std_vector_Sl_SVertex_Sm__Sg____len__(std::vector<SVertex * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg__pop(std::vector<SVertex * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<SVertex*,std::allocator<SVertex * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<SVertex *,std::allocator<SVertex * > > *std_vector_Sl_SVertex_Sm__Sg____getslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j,std::vector<SVertex *,std::allocator<SVertex * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg____getitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg__append(std::vector<SVertex * > *self,std::vector<SVertex * >::value_type x){
+      self->push_back(x);
+    }
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (PyString_Check(obj)) {
+    char *cstr; Py_ssize_t len;
+    PyString_AsStringAndSize(obj, &cstr, &len);
+    if (cptr)  {
+      if (alloc) {
+	/* 
+	   In python the user should not be able to modify the inner
+	   string representation. To warranty that, if you define
+	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
+	   buffer is always returned.
+
+	   The default behavior is just to return the pointer value,
+	   so, be careful.
+	*/ 
+#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
+	if (*alloc != SWIG_OLDOBJ) 
+#else
+	if (*alloc == SWIG_NEWOBJ) 
+#endif
+	  {
+	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
+	    *alloc = SWIG_NEWOBJ;
+	  }
+	else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      } else {
+	*cptr = PyString_AsString(obj);
+      }
+    }
+    if (psize) *psize = len + 1;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *) vptr;
+	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
+{
+  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
+  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
+    if (buf) {
+      if (val) *val = new std::string(buf, size - 1);
+      if (alloc == SWIG_NEWOBJ) delete[] buf;
+      return SWIG_NEWOBJ;
+    } else {
+      if (val) *val = 0;
+      return SWIG_OLDOBJ;
+    }
+  } else {
+    static int init = 0;
+    static swig_type_info* descriptor = 0;
+    if (!init) {
+      descriptor = SWIG_TypeQuery("std::string" " *");
+      init = 1;
+    }
+    if (descriptor) {
+      std::string *vptr;
+      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
+      if (SWIG_IsOK(res) && val) *val = vptr;
+      return res;
+    }
+  }
+  return SWIG_ERROR;
+}
+
+
+
+
+
+  namespace swig {
+    template <>  struct traits<StrokeShader > {
+      typedef pointer_category category;
+      static const char* type_name() { return"StrokeShader"; }
+    };
+  }
+
+
+      namespace swig {
+	template <>  struct traits<std::vector<StrokeShader*, std::allocator<StrokeShader * > > > {
+	  typedef value_category category;
+	  static const char* type_name() {
+	    return "std::vector<" "StrokeShader" " *," "std::allocator<StrokeShader * >" " >";
+	  }
+	};
+      }
+    
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_StrokeShader_Sm__Sg__iterator(std::vector<StrokeShader * > *self,PyObject **PYTHON_SELF){
+      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+    }
+SWIGINTERN bool std_vector_Sl_StrokeShader_Sm__Sg____nonzero__(std::vector<StrokeShader * > const *self){
+      return !(self->empty());
+    }
+SWIGINTERN std::vector<StrokeShader * >::size_type std_vector_Sl_StrokeShader_Sm__Sg____len__(std::vector<StrokeShader * > const *self){
+      return self->size();
+    }
+SWIGINTERN std::vector<StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg__pop(std::vector<StrokeShader * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<StrokeShader*,std::allocator<StrokeShader * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
+SWIGINTERN std::vector<StrokeShader *,std::allocator<StrokeShader * > > *std_vector_Sl_StrokeShader_Sm__Sg____getslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j){
+      return swig::getslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j,std::vector<StrokeShader *,std::allocator<StrokeShader * > > const &v){
+      swig::setslice(self, i, j, v);
+    }
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j){
+      swig::delslice(self, i, j);
+    }
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i){
+      self->erase(swig::getpos(self,i));
+    }
+SWIGINTERN std::vector<StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg____getitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i){
+      return *(swig::cgetpos(self, i));
+    }
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::value_type x){
+      *(swig::getpos(self,i)) = x;
+    }
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg__append(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::value_type x){
+      self->push_back(x);
+    }
+
+
+/* ---------------------------------------------------
+ * C++ director class methods
+ * --------------------------------------------------- */
+
+#include "ModuleWrapper.h"
+
+SwigDirector_ViewEdgeViewEdgeIterator::SwigDirector_ViewEdgeViewEdgeIterator(PyObject *self, ViewEdge *begin, bool orientation): ViewEdgeInternal::ViewEdgeIterator(begin, orientation), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ViewEdgeInternal::ViewEdgeIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ViewEdgeViewEdgeIterator::SwigDirector_ViewEdgeViewEdgeIterator(PyObject *self, ViewEdgeInternal::ViewEdgeIterator const &it): ViewEdgeInternal::ViewEdgeIterator(it), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ViewEdgeInternal::ViewEdgeIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ViewEdgeViewEdgeIterator::~SwigDirector_ViewEdgeViewEdgeIterator() {
+}
+
+std::string SwigDirector_ViewEdgeViewEdgeIterator::getExactTypeName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getExactTypeName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getExactTypeName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.getExactTypeName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+ViewEdge *SwigDirector_ViewEdgeViewEdgeIterator::operator *() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "getObject";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getObject", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.getObject'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdge *SwigDirector_ViewEdgeViewEdgeIterator::operator ->() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 2;
+  const char * const swig_method_name = "__deref__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "__deref__", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.__deref__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ViewEdgeViewEdgeIterator::operator ++() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ViewEdgeViewEdgeIterator::operator ++(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++(arg0);
+}
+
+
+void SwigDirector_ViewEdgeViewEdgeIterator::increment() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 3;
+  const char * const swig_method_name = "increment";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "increment", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.increment'");
+    }
+  }
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ViewEdgeViewEdgeIterator::operator --() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ViewEdgeViewEdgeIterator::operator --(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --(arg0);
+}
+
+
+void SwigDirector_ViewEdgeViewEdgeIterator::decrement() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 4;
+  const char * const swig_method_name = "decrement";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "decrement", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.decrement'");
+    }
+  }
+}
+
+
+bool SwigDirector_ViewEdgeViewEdgeIterator::isBegin() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 5;
+  const char * const swig_method_name = "isBegin";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isBegin", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.isBegin'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ViewEdgeViewEdgeIterator::isEnd() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 6;
+  const char * const swig_method_name = "isEnd";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isEnd", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.isEnd'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ViewEdgeViewEdgeIterator::operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 7;
+  const char * const swig_method_name = "__eq__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__eq__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.__eq__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ViewEdgeViewEdgeIterator::operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ViewEdgeViewEdgeIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 8;
+  const char * const swig_method_name = "__ne__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__ne__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ViewEdgeViewEdgeIterator.__ne__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DVoid::SwigDirector_UnaryFunction0DVoid(PyObject *self): UnaryFunction0D<void >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<void > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DVoid::~SwigDirector_UnaryFunction0DVoid() {
+}
+
+std::string SwigDirector_UnaryFunction0DVoid::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVoid.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVoid.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+void SwigDirector_UnaryFunction0DVoid::operator ()(Interface0DIterator &iter) {
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVoid.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVoid.__call__'");
+    }
+  }
+}
+
+
+SwigDirector_UnaryFunction0DUnsigned::SwigDirector_UnaryFunction0DUnsigned(PyObject *self): UnaryFunction0D<unsigned int >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<unsigned int > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DUnsigned::~SwigDirector_UnaryFunction0DUnsigned() {
+}
+
+std::string SwigDirector_UnaryFunction0DUnsigned::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DUnsigned.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DUnsigned.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+unsigned int SwigDirector_UnaryFunction0DUnsigned::operator ()(Interface0DIterator &iter) {
+  unsigned int c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DUnsigned.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DUnsigned.__call__'");
+    }
+  }
+  unsigned int swig_val;
+  int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""unsigned int""'");
+  }
+  c_result = static_cast< unsigned int >(swig_val);
+  return (unsigned int) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DFloat::SwigDirector_UnaryFunction0DFloat(PyObject *self): UnaryFunction0D<float >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<float > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DFloat::~SwigDirector_UnaryFunction0DFloat() {
+}
+
+std::string SwigDirector_UnaryFunction0DFloat::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DFloat.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DFloat.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+float SwigDirector_UnaryFunction0DFloat::operator ()(Interface0DIterator &iter) {
+  float c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DFloat.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DFloat.__call__'");
+    }
+  }
+  float swig_val;
+  int swig_res = SWIG_AsVal_float(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""float""'");
+  }
+  c_result = static_cast< float >(swig_val);
+  return (float) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DDouble::SwigDirector_UnaryFunction0DDouble(PyObject *self): UnaryFunction0D<double >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<double > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DDouble::~SwigDirector_UnaryFunction0DDouble() {
+}
+
+std::string SwigDirector_UnaryFunction0DDouble::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DDouble.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DDouble.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+double SwigDirector_UnaryFunction0DDouble::operator ()(Interface0DIterator &iter) {
+  double c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DDouble.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DDouble.__call__'");
+    }
+  }
+  double swig_val;
+  int swig_res = SWIG_AsVal_double(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
+  }
+  c_result = static_cast< double >(swig_val);
+  return (double) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DVec2f::SwigDirector_UnaryFunction0DVec2f(PyObject *self): UnaryFunction0D<Geometry::Vec2f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Geometry::Vec2f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DVec2f::~SwigDirector_UnaryFunction0DVec2f() {
+}
+
+std::string SwigDirector_UnaryFunction0DVec2f::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVec2f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec2f.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+VecMat::Vec2<float > SwigDirector_UnaryFunction0DVec2f::operator ()(Interface0DIterator &iter) {
+  void *swig_argp ;
+  int swig_res = 0 ;
+  
+  VecMat::Vec2<float > c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVec2f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec2f.__call__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2<float >""'");
+  }
+  c_result = *(reinterpret_cast< VecMat::Vec2<float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2<float > * >(swig_argp);
+  return (VecMat::Vec2<float >) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DVec3f::SwigDirector_UnaryFunction0DVec3f(PyObject *self): UnaryFunction0D<Geometry::Vec3f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Geometry::Vec3f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DVec3f::~SwigDirector_UnaryFunction0DVec3f() {
+}
+
+std::string SwigDirector_UnaryFunction0DVec3f::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVec3f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec3f.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+VecMat::Vec3<float > SwigDirector_UnaryFunction0DVec3f::operator ()(Interface0DIterator &iter) {
+  void *swig_argp ;
+  int swig_res = 0 ;
+  
+  VecMat::Vec3<float > c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DVec3f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec3f.__call__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3<float >""'");
+  }
+  c_result = *(reinterpret_cast< VecMat::Vec3<float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3<float > * >(swig_argp);
+  return (VecMat::Vec3<float >) c_result;
+}
+
+
+SwigDirector_UnaryFunction0DId::SwigDirector_UnaryFunction0DId(PyObject *self): UnaryFunction0D<Id >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Id > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction0DId::~SwigDirector_UnaryFunction0DId() {
+}
+
+std::string SwigDirector_UnaryFunction0DId::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DId.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DId.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+Id SwigDirector_UnaryFunction0DId::operator ()(Interface0DIterator &iter) {
+  void *swig_argp ;
+  int swig_res = 0 ;
+  
+  Id c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction0DId.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DId.__call__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Id""'");
+  }
+  c_result = *(reinterpret_cast< Id * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Id * >(swig_argp);
+  return (Id) c_result;
+}
+
+
+SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self): UnaryFunction1D<void >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<void > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self, IntegrationType iType): UnaryFunction1D<void >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<void > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVoid::~SwigDirector_UnaryFunction1DVoid() {
+}
+
+std::string SwigDirector_UnaryFunction1DVoid::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVoid.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVoid.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+void SwigDirector_UnaryFunction1DVoid::operator ()(Interface1D &inter) {
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVoid.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVoid.__call__'");
+    }
+  }
+}
+
+
+SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self): UnaryFunction1D<unsigned int >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<unsigned int > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self, IntegrationType iType): UnaryFunction1D<unsigned int >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<unsigned int > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DUnsigned::~SwigDirector_UnaryFunction1DUnsigned() {
+}
+
+std::string SwigDirector_UnaryFunction1DUnsigned::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DUnsigned.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DUnsigned.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+unsigned int SwigDirector_UnaryFunction1DUnsigned::operator ()(Interface1D &inter) {
+  unsigned int c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DUnsigned.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DUnsigned.__call__'");
+    }
+  }
+  unsigned int swig_val;
+  int swig_res = SWIG_AsVal_unsigned_SS_int(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""unsigned int""'");
+  }
+  c_result = static_cast< unsigned int >(swig_val);
+  return (unsigned int) c_result;
+}
+
+
+SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self): UnaryFunction1D<float >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<float > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self, IntegrationType iType): UnaryFunction1D<float >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<float > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DFloat::~SwigDirector_UnaryFunction1DFloat() {
+}
+
+std::string SwigDirector_UnaryFunction1DFloat::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DFloat.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DFloat.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+float SwigDirector_UnaryFunction1DFloat::operator ()(Interface1D &inter) {
+  float c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DFloat.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DFloat.__call__'");
+    }
+  }
+  float swig_val;
+  int swig_res = SWIG_AsVal_float(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""float""'");
+  }
+  c_result = static_cast< float >(swig_val);
+  return (float) c_result;
+}
+
+
+SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self): UnaryFunction1D<double >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<double > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self, IntegrationType iType): UnaryFunction1D<double >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<double > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DDouble::~SwigDirector_UnaryFunction1DDouble() {
+}
+
+std::string SwigDirector_UnaryFunction1DDouble::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DDouble.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DDouble.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+double SwigDirector_UnaryFunction1DDouble::operator ()(Interface1D &inter) {
+  double c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DDouble.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DDouble.__call__'");
+    }
+  }
+  double swig_val;
+  int swig_res = SWIG_AsVal_double(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
+  }
+  c_result = static_cast< double >(swig_val);
+  return (double) c_result;
+}
+
+
+SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self): UnaryFunction1D<Geometry::Vec2f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec2f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self, IntegrationType iType): UnaryFunction1D<Geometry::Vec2f >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec2f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVec2f::~SwigDirector_UnaryFunction1DVec2f() {
+}
+
+std::string SwigDirector_UnaryFunction1DVec2f::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVec2f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec2f.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+VecMat::Vec2<float > SwigDirector_UnaryFunction1DVec2f::operator ()(Interface1D &inter) {
+  void *swig_argp ;
+  int swig_res = 0 ;
+  
+  VecMat::Vec2<float > c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVec2f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec2f.__call__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2<float >""'");
+  }
+  c_result = *(reinterpret_cast< VecMat::Vec2<float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2<float > * >(swig_argp);
+  return (VecMat::Vec2<float >) c_result;
+}
+
+
+SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self): UnaryFunction1D<Geometry::Vec3f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec3f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self, IntegrationType iType): UnaryFunction1D<Geometry::Vec3f >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec3f > *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryFunction1DVec3f::~SwigDirector_UnaryFunction1DVec3f() {
+}
+
+std::string SwigDirector_UnaryFunction1DVec3f::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVec3f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec3f.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+VecMat::Vec3<float > SwigDirector_UnaryFunction1DVec3f::operator ()(Interface1D &inter) {
+  void *swig_argp ;
+  int swig_res = 0 ;
+  
+  VecMat::Vec3<float > c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryFunction1DVec3f.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec3f.__call__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3<float >""'");
+  }
+  c_result = *(reinterpret_cast< VecMat::Vec3<float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3<float > * >(swig_argp);
+  return (VecMat::Vec3<float >) c_result;
+}
+
+
+SwigDirector_ChainingIterator::SwigDirector_ChainingIterator(PyObject *self, bool iRestrictToSelection, bool iRestrictToUnvisited, ViewEdge *begin, bool orientation): ChainingIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainingIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainingIterator::SwigDirector_ChainingIterator(PyObject *self, ChainingIterator const &brother): ChainingIterator(brother), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainingIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainingIterator::~SwigDirector_ChainingIterator() {
+}
+
+std::string SwigDirector_ChainingIterator::getExactTypeName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getExactTypeName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getExactTypeName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.getExactTypeName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainingIterator::operator *() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "getObject";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getObject", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.getObject'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainingIterator::operator ->() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 2;
+  const char * const swig_method_name = "__deref__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "__deref__", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.__deref__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainingIterator::operator ++() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainingIterator::operator ++(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++(arg0);
+}
+
+
+void SwigDirector_ChainingIterator::increment() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 3;
+  const char * const swig_method_name = "increment";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "increment", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.increment'");
+    }
+  }
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainingIterator::operator --() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainingIterator::operator --(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --(arg0);
+}
+
+
+void SwigDirector_ChainingIterator::decrement() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 4;
+  const char * const swig_method_name = "decrement";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "decrement", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.decrement'");
+    }
+  }
+}
+
+
+bool SwigDirector_ChainingIterator::isBegin() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 5;
+  const char * const swig_method_name = "isBegin";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isBegin", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.isBegin'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainingIterator::isEnd() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 6;
+  const char * const swig_method_name = "isEnd";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isEnd", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.isEnd'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainingIterator::operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 7;
+  const char * const swig_method_name = "__eq__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__eq__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.__eq__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainingIterator::operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 8;
+  const char * const swig_method_name = "__ne__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__ne__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.__ne__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+void SwigDirector_ChainingIterator::init() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 9;
+  const char * const swig_method_name = "init";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "init", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.init'");
+    }
+  }
+}
+
+
+ViewEdge *SwigDirector_ChainingIterator::traverse(AdjacencyIterator const &it) {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_AdjacencyIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainingIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 10;
+  const char * const swig_method_name = "traverse";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"traverse", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainingIterator.traverse'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+SwigDirector_ChainSilhouetteIterator::SwigDirector_ChainSilhouetteIterator(PyObject *self, bool iRestrictToSelection, ViewEdge *begin, bool orientation): ChainSilhouetteIterator(iRestrictToSelection, begin, orientation), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainSilhouetteIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainSilhouetteIterator::SwigDirector_ChainSilhouetteIterator(PyObject *self, ChainSilhouetteIterator const &brother): ChainSilhouetteIterator(brother), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainSilhouetteIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainSilhouetteIterator::~SwigDirector_ChainSilhouetteIterator() {
+}
+
+std::string SwigDirector_ChainSilhouetteIterator::getExactTypeName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getExactTypeName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getExactTypeName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.getExactTypeName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainSilhouetteIterator::operator *() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "getObject";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getObject", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.getObject'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainSilhouetteIterator::operator ->() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 2;
+  const char * const swig_method_name = "__deref__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "__deref__", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.__deref__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainSilhouetteIterator::operator ++() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainSilhouetteIterator::operator ++(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++(arg0);
+}
+
+
+void SwigDirector_ChainSilhouetteIterator::increment() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 3;
+  const char * const swig_method_name = "increment";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "increment", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.increment'");
+    }
+  }
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainSilhouetteIterator::operator --() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainSilhouetteIterator::operator --(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --(arg0);
+}
+
+
+void SwigDirector_ChainSilhouetteIterator::decrement() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 4;
+  const char * const swig_method_name = "decrement";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "decrement", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.decrement'");
+    }
+  }
+}
+
+
+bool SwigDirector_ChainSilhouetteIterator::isBegin() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 5;
+  const char * const swig_method_name = "isBegin";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isBegin", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.isBegin'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainSilhouetteIterator::isEnd() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 6;
+  const char * const swig_method_name = "isEnd";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isEnd", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.isEnd'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainSilhouetteIterator::operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 7;
+  const char * const swig_method_name = "__eq__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__eq__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.__eq__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainSilhouetteIterator::operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 8;
+  const char * const swig_method_name = "__ne__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__ne__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.__ne__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+void SwigDirector_ChainSilhouetteIterator::init() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 9;
+  const char * const swig_method_name = "init";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "init", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.init'");
+    }
+  }
+}
+
+
+ViewEdge *SwigDirector_ChainSilhouetteIterator::traverse(AdjacencyIterator const &it) {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_AdjacencyIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainSilhouetteIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 10;
+  const char * const swig_method_name = "traverse";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"traverse", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainSilhouetteIterator.traverse'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+SwigDirector_ChainPredicateIterator::SwigDirector_ChainPredicateIterator(PyObject *self, bool iRestrictToSelection, bool iRestrictToUnvisited, ViewEdge *begin, bool orientation): ChainPredicateIterator(iRestrictToSelection, iRestrictToUnvisited, begin, orientation), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainPredicateIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainPredicateIterator::SwigDirector_ChainPredicateIterator(PyObject *self, UnaryPredicate1D &upred, BinaryPredicate1D &bpred, bool iRestrictToSelection, bool iRestrictToUnvisited, ViewEdge *begin, bool orientation): ChainPredicateIterator(upred, bpred, iRestrictToSelection, iRestrictToUnvisited, begin, orientation), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainPredicateIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainPredicateIterator::SwigDirector_ChainPredicateIterator(PyObject *self, ChainPredicateIterator const &brother): ChainPredicateIterator(brother), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((ChainPredicateIterator *)this, this); 
+}
+
+
+
+
+SwigDirector_ChainPredicateIterator::~SwigDirector_ChainPredicateIterator() {
+}
+
+std::string SwigDirector_ChainPredicateIterator::getExactTypeName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getExactTypeName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getExactTypeName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.getExactTypeName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainPredicateIterator::operator *() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "getObject";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getObject", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.getObject'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdge *SwigDirector_ChainPredicateIterator::operator ->() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 2;
+  const char * const swig_method_name = "__deref__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "__deref__", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.__deref__'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainPredicateIterator::operator ++() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainPredicateIterator::operator ++(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator ++(arg0);
+}
+
+
+void SwigDirector_ChainPredicateIterator::increment() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 3;
+  const char * const swig_method_name = "increment";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "increment", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.increment'");
+    }
+  }
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator &SwigDirector_ChainPredicateIterator::operator --() {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --();
+}
+
+
+ViewEdgeInternal::ViewEdgeIterator SwigDirector_ChainPredicateIterator::operator --(int arg0) {
+  return ViewEdgeInternal::ViewEdgeIterator::operator --(arg0);
+}
+
+
+void SwigDirector_ChainPredicateIterator::decrement() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 4;
+  const char * const swig_method_name = "decrement";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "decrement", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.decrement'");
+    }
+  }
+}
+
+
+bool SwigDirector_ChainPredicateIterator::isBegin() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 5;
+  const char * const swig_method_name = "isBegin";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isBegin", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.isBegin'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainPredicateIterator::isEnd() const {
+  bool c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 6;
+  const char * const swig_method_name = "isEnd";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "isEnd", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.isEnd'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainPredicateIterator::operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 7;
+  const char * const swig_method_name = "__eq__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__eq__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.__eq__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+bool SwigDirector_ChainPredicateIterator::operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 8;
+  const char * const swig_method_name = "__ne__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__ne__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.__ne__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+void SwigDirector_ChainPredicateIterator::init() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 9;
+  const char * const swig_method_name = "init";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "init", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.init'");
+    }
+  }
+}
+
+
+ViewEdge *SwigDirector_ChainPredicateIterator::traverse(AdjacencyIterator const &it) {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  ViewEdge *c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_AdjacencyIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ChainPredicateIterator.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 10;
+  const char * const swig_method_name = "traverse";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"traverse", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'ChainPredicateIterator.traverse'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_ViewEdge,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
+  }
+  c_result = reinterpret_cast< ViewEdge * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  return (ViewEdge *) c_result;
+}
+
+
+SwigDirector_UnaryPredicate0D::SwigDirector_UnaryPredicate0D(PyObject *self): UnaryPredicate0D(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryPredicate0D *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryPredicate0D::~SwigDirector_UnaryPredicate0D() {
+}
+
+std::string SwigDirector_UnaryPredicate0D::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryPredicate0D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryPredicate0D.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+bool SwigDirector_UnaryPredicate0D::operator ()(Interface0DIterator &it) {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&it), SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryPredicate0D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryPredicate0D.__call__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+SwigDirector_UnaryPredicate1D::SwigDirector_UnaryPredicate1D(PyObject *self): UnaryPredicate1D(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryPredicate1D *)this, this); 
+}
+
+
+
+
+SwigDirector_UnaryPredicate1D::~SwigDirector_UnaryPredicate1D() {
+}
+
+std::string SwigDirector_UnaryPredicate1D::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryPredicate1D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryPredicate1D.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+bool SwigDirector_UnaryPredicate1D::operator ()(Interface1D &inter) {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UnaryPredicate1D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'UnaryPredicate1D.__call__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+SwigDirector_BinaryPredicate1D::SwigDirector_BinaryPredicate1D(PyObject *self): BinaryPredicate1D(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((BinaryPredicate1D *)this, this); 
+}
+
+
+
+
+SwigDirector_BinaryPredicate1D::~SwigDirector_BinaryPredicate1D() {
+}
+
+std::string SwigDirector_BinaryPredicate1D::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BinaryPredicate1D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'BinaryPredicate1D.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+bool SwigDirector_BinaryPredicate1D::operator ()(Interface1D &inter1, Interface1D &inter2) {
+  bool c_result;
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter1), SWIGTYPE_p_Interface1D,  0 );
+  swig::PyObject_var obj1;
+  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter2), SWIGTYPE_p_Interface1D,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BinaryPredicate1D.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "__call__";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"__call__", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'BinaryPredicate1D.__call__'");
+    }
+  }
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
+SwigDirector_StrokeShader::SwigDirector_StrokeShader(PyObject *self): StrokeShader(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((StrokeShader *)this, this); 
+}
+
+
+
+
+SwigDirector_StrokeShader::~SwigDirector_StrokeShader() {
+}
+
+std::string SwigDirector_StrokeShader::getName() const {
+  std::string c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StrokeShader.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "getName";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *) "getName", NULL);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'StrokeShader.getName'");
+    }
+  }
+  std::string *swig_optr = 0;
+  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
+  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
+  }
+  c_result = *swig_optr;
+  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
+  return (std::string) c_result;
+}
+
+
+void SwigDirector_StrokeShader::shade(Stroke &ioStroke) const {
+  swig::PyObject_var obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&ioStroke), SWIGTYPE_p_Stroke,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call StrokeShader.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "shade";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::PyObject_var result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::PyObject_var result = PyObject_CallMethod(swig_get_self(), (char *)"shade", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (result == NULL) {
+    PyObject *error = PyErr_Occurred();
+    if (error != NULL) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'StrokeShader.shade'");
+    }
+  }
+}
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_PySwigIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  delete arg1;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  PyObject *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_value",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  try {
+    result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = result;
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  size_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_incr",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
+  } 
+  arg2 = static_cast< size_t >(val2);
+  try {
+    result = (swig::PySwigIterator *)(arg1)->incr(arg2);
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_incr",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  try {
+    result = (swig::PySwigIterator *)(arg1)->incr();
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_PySwigIterator_incr__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_PySwigIterator_incr__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n  Possible C/C++ prototypes are:\n    incr(size_t)\n    incr()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  size_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_decr",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
+  } 
+  arg2 = static_cast< size_t >(val2);
+  try {
+    result = (swig::PySwigIterator *)(arg1)->decr(arg2);
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_decr",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  try {
+    result = (swig::PySwigIterator *)(arg1)->decr();
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_PySwigIterator_decr__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_PySwigIterator_decr__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n  Possible C/C++ prototypes are:\n    decr(size_t)\n    decr()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *arg2 = 0 ;
+  ptrdiff_t result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_distance",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+  try {
+    result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+  }
+  
+  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_equal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+  try {
+    result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
+  }
+  
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  PyObject *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_next",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  try {
+    result = (PyObject *)(arg1)->next();
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = result;
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  PyObject *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:PySwigIterator_previous",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  try {
+    result = (PyObject *)(arg1)->previous();
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = result;
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  ptrdiff_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator_advance",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
+  } 
+  arg2 = static_cast< ptrdiff_t >(val2);
+  try {
+    result = (swig::PySwigIterator *)(arg1)->advance(arg2);
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+  result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+  result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  ptrdiff_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___iadd__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
+  } 
+  arg2 = static_cast< ptrdiff_t >(val2);
+  try {
+    {
+      swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
+      result = (swig::PySwigIterator *) &_result_ref;
+    }
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  ptrdiff_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___isub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+  } 
+  arg2 = static_cast< ptrdiff_t >(val2);
+  try {
+    {
+      swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
+      result = (swig::PySwigIterator *) &_result_ref;
+    }
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  ptrdiff_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
+  } 
+  arg2 = static_cast< ptrdiff_t >(val2);
+  try {
+    result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  ptrdiff_t arg2 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
+  } 
+  arg2 = static_cast< ptrdiff_t >(val2);
+  try {
+    result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
+  }
+  catch(swig::stop_iteration &_e) {
+    {
+      (void)_e;
+      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
+      SWIG_fail;
+    }
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
+  swig::PySwigIterator *arg2 = 0 ;
+  ptrdiff_t result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PySwigIterator___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
+  result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
+  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_PySwigIterator___sub____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_PySwigIterator___sub____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_vectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_iterator" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___nonzero__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector<int > const *)arg1);
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___len__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = std_vector_Sl_int_Sg____len__((std::vector<int > const *)arg1);
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_pop" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  try {
+    result = (std::vector<int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  std::vector<int >::difference_type arg3 ;
+  std::vector<int,std::allocator<int > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___getslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___getslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___getslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  try {
+    result = (std::vector<int,std::allocator<int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  std::vector<int >::difference_type arg3 ;
+  std::vector<int,std::allocator<int > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___setslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___setslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___setslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  {
+    std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector<int,std::allocator<int > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  std::vector<int >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___delslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___delslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___delslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  try {
+    std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___delitem__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___delitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  try {
+    std_vector_Sl_int_Sg____delitem__(arg1,arg2);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  std::vector<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___getitem__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___getitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  try {
+    {
+      std::vector<int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector<int > const *)arg1,arg2);
+      result = (std::vector<int >::value_type *) &_result_ref;
+    }
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_int(static_cast< int >(*result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::difference_type arg2 ;
+  std::vector<int >::value_type *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  std::vector<int >::value_type temp3 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___setitem__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___setitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___setitem__" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  arg3 = &temp3;
+  try {
+    std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::value_type *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  std::vector<int >::value_type temp2 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_append" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_append" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  arg2 = &temp2;
+  std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_vectorInt")) SWIG_fail;
+  result = (std::vector<int > *)new std::vector<int >();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = 0 ;
+  std::vector<int > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_vectorInt",&obj0)) SWIG_fail;
+  {
+    std::vector<int,std::allocator<int > > *ptr = (std::vector<int,std::allocator<int > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_empty" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (bool)((std::vector<int > const *)arg1)->empty();
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_size" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->size();
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_clear" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_swap" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<int > * >(argp2);
+  (arg1)->swap(*arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  SwigValueWrapper<std::allocator<int > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_get_allocator" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector<int >::allocator_type(static_cast< const std::vector<int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_begin" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (arg1)->begin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_begin" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->begin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_end" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (arg1)->end();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_end" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->end();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (arg1)->rbegin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->rbegin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rend" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = (arg1)->rend();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rend" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->rend();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_vectorInt_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int >::size_type arg1 ;
+  std::vector<int > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_vectorInt",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<int >::size_type >(val1);
+  result = (std::vector<int > *)new std::vector<int >(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_pop_back" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  (arg1)->pop_back();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  (arg1)->resize(arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator arg2 ;
+  std::vector<int >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    }
+  }
+  result = (arg1)->erase(arg2);
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator arg2 ;
+  std::vector<int >::iterator arg3 ;
+  std::vector<int >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+    }
+  }
+  result = (arg1)->erase(arg2,arg3);
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_vectorInt_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_vectorInt_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<int >::iterator)\n    erase(std::vector<int >::iterator,std::vector<int >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int >::size_type arg1 ;
+  std::vector<int >::value_type *arg2 = 0 ;
+  std::vector<int > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  std::vector<int >::value_type temp2 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_vectorInt",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<int >::size_type >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectorInt" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  arg2 = &temp2;
+  result = (std::vector<int > *)new std::vector<int >(arg1,(std::vector<int >::value_type const &)*arg2);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_vectorInt(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_vectorInt__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_vectorInt__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_vectorInt__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_vectorInt__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_vectorInt'.\n  Possible C/C++ prototypes are:\n    std::vector<(int)>()\n    std::vector<(int)>(std::vector<int > const &)\n    std::vector<(int)>(std::vector<int >::size_type)\n    std::vector<(int)>(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::value_type *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  std::vector<int >::value_type temp2 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_push_back" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_push_back" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  arg2 = &temp2;
+  (arg1)->push_back((std::vector<int >::value_type const &)*arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_front" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  {
+    std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->front();
+    result = (std::vector<int >::value_type *) &_result_ref;
+  }
+  resultobj = SWIG_From_int(static_cast< int >(*result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_back" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  {
+    std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->back();
+    result = (std::vector<int >::value_type *) &_result_ref;
+  }
+  resultobj = SWIG_From_int(static_cast< int >(*result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type arg2 ;
+  std::vector<int >::value_type *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  std::vector<int >::value_type temp3 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_assign" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_assign" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_assign" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  arg3 = &temp3;
+  (arg1)->assign(arg2,(std::vector<int >::value_type const &)*arg3);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type arg2 ;
+  std::vector<int >::value_type *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  std::vector<int >::value_type temp3 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_resize" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  arg3 = &temp3;
+  (arg1)->resize(arg2,(std::vector<int >::value_type const &)*arg3);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_vectorInt_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_vectorInt_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<int >::size_type)\n    resize(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator arg2 ;
+  std::vector<int >::value_type *arg3 = 0 ;
+  std::vector<int >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  std::vector<int >::value_type temp3 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  arg3 = &temp3;
+  result = (arg1)->insert(arg2,(std::vector<int >::value_type const &)*arg3);
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::iterator arg2 ;
+  std::vector<int >::size_type arg3 ;
+  std::vector<int >::value_type *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  std::vector<int >::value_type temp4 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<int >::size_type >(val3);
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vectorInt_insert" "', argument " "4"" of type '" "std::vector<int >::value_type""'");
+  } 
+  temp4 = static_cast< std::vector<int >::value_type >(val4);
+  arg4 = &temp4;
+  (arg1)->insert(arg2,arg3,(std::vector<int >::value_type const &)*arg4);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_vectorInt_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_vectorInt_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<int >::iterator,std::vector<int >::value_type const &)\n    insert(std::vector<int >::iterator,std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_reserve" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_reserve" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  (arg1)->reserve(arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector<int >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_capacity" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  result = ((std::vector<int > const *)arg1)->capacity();
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_vectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_vectorInt",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorInt" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *vectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Id__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Id")) SWIG_fail;
+  {
+    try {
+      result = (Id *)new Id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Id__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id::id_type arg1 ;
+  Id *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Id",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Id" "', argument " "1"" of type '" "Id::id_type""'");
+  } 
+  arg1 = static_cast< Id::id_type >(val1);
+  {
+    try {
+      result = (Id *)new Id(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Id__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id::id_type arg1 ;
+  Id::id_type arg2 ;
+  Id *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Id",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Id" "', argument " "1"" of type '" "Id::id_type""'");
+  } 
+  arg1 = static_cast< Id::id_type >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Id" "', argument " "2"" of type '" "Id::id_type""'");
+  } 
+  arg2 = static_cast< Id::id_type >(val2);
+  {
+    try {
+      result = (Id *)new Id(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Id__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = 0 ;
+  Id *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Id" "', argument " "1"" of type '" "Id const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Id" "', argument " "1"" of type '" "Id const &""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  {
+    try {
+      result = (Id *)new Id((Id const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Id(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Id__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Id, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Id__SWIG_3(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Id__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Id__SWIG_2(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Id'.\n  Possible C/C++ prototypes are:\n    Id()\n    Id(Id::id_type)\n    Id(Id::id_type,Id::id_type)\n    Id(Id const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id_getFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id::id_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Id_getFirst",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id_getFirst" "', argument " "1"" of type '" "Id const *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  {
+    try {
+      result = (Id::id_type)((Id const *)arg1)->getFirst();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id_getSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id::id_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Id_getSecond",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id_getSecond" "', argument " "1"" of type '" "Id const *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  {
+    try {
+      result = (Id::id_type)((Id const *)arg1)->getSecond();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id_setFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id::id_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Id_setFirst",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id_setFirst" "', argument " "1"" of type '" "Id *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Id_setFirst" "', argument " "2"" of type '" "Id::id_type""'");
+  } 
+  arg2 = static_cast< Id::id_type >(val2);
+  {
+    try {
+      (arg1)->setFirst(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id_setSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id::id_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Id_setSecond",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id_setSecond" "', argument " "1"" of type '" "Id *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Id_setSecond" "', argument " "2"" of type '" "Id::id_type""'");
+  } 
+  arg2 = static_cast< Id::id_type >(val2);
+  {
+    try {
+      (arg1)->setSecond(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Id___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id___eq__" "', argument " "1"" of type '" "Id const *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Id___eq__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Id___eq__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      result = (bool)((Id const *)arg1)->operator ==((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Id___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id___ne__" "', argument " "1"" of type '" "Id const *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Id___ne__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Id___ne__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      result = (bool)((Id const *)arg1)->operator !=((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Id___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  Id *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Id___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Id___lt__" "', argument " "1"" of type '" "Id const *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Id___lt__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Id___lt__" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      result = (bool)((Id const *)arg1)->operator <((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = (Id *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Id, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Id" "', argument " "1"" of type '" "Id *""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Id, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_2u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_2u")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,2 > *)new VecMat::Vec<unsigned int,2 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_2u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2u" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_2u_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<unsigned int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_norm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalize" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<unsigned int,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<unsigned int,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<unsigned int,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<unsigned int,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___add__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator +((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___sub__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator -((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 >::value_type arg2 ;
+  VecMat::Vec<unsigned int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<unsigned int,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 >::value_type arg2 ;
+  VecMat::Vec<unsigned int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___div__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___div__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<unsigned int,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator *((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_2u___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_2u___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___eq__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator ==((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___ne__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator !=((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___lt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator <((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2u___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___gt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator >((VecMat::Vec<unsigned int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_2u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_2i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_2i")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<int,2 > *)new VecMat::Vec<int,2 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_2i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2i",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2i" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_2i_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_norm" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalize" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<int,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<int,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<int,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<int,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec<int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___add__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<int,2 > const *)arg1)->operator +((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec<int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___sub__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<int,2 > const *)arg1)->operator -((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 >::value_type arg2 ;
+  VecMat::Vec<int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<int,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<int,2 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 >::value_type arg2 ;
+  VecMat::Vec<int,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___div__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___div__" "', argument " "2"" of type '" "VecMat::Vec<int,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<int,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<int,2 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec<int,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->operator *((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTint_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTint_2_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_2i___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTint_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_2i___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___eq__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator ==((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___ne__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator !=((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___lt__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator <((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2i___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec<int,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___gt__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator >((VecMat::Vec<int,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_2i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_2d")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<double,2 > *)new VecMat::Vec<double,2 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2d" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_2d_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<double,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_norm" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalize" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<double,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<double,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<double,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<double,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec<double,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___add__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<double,2 > const *)arg1)->operator +((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec<double,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___sub__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<double,2 > const *)arg1)->operator -((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 >::value_type arg2 ;
+  VecMat::Vec<double,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<double,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<double,2 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 >::value_type arg2 ;
+  VecMat::Vec<double,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___div__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___div__" "', argument " "2"" of type '" "VecMat::Vec<double,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<double,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<double,2 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec<double,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->operator *((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTdouble_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTdouble_2_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_2d___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTdouble_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_2d___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___eq__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator ==((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___ne__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator !=((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___lt__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator <((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2d___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec<double,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___gt__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator >((VecMat::Vec<double,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_2f")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<float,2 > *)new VecMat::Vec<float,2 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2f" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_2f_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<float,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_norm" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalize" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<float,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<float,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<float,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<float,2 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec<float,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___add__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<float,2 > const *)arg1)->operator +((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec<float,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___sub__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<float,2 > const *)arg1)->operator -((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 >::value_type arg2 ;
+  VecMat::Vec<float,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<float,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<float,2 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 >::value_type arg2 ;
+  VecMat::Vec<float,2 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___div__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___div__" "', argument " "2"" of type '" "VecMat::Vec<float,2 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<float,2 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<float,2 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec<float,2 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->operator *((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTfloat_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTfloat_2_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_2f___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTfloat_2_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_2f___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___eq__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator ==((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___ne__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator !=((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___lt__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator <((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_2f___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec<float,2 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___gt__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator >((VecMat::Vec<float,2 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec2u")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int >::value_type arg1 ;
+  VecMat::Vec2<unsigned int >::value_type arg2 ;
+  VecMat::Vec2<unsigned int > *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec2u",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2u" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int >::value_type arg1 ;
+  VecMat::Vec2<unsigned int > *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec2u",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2u(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec2u__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec2u__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec2u__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2u'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec2<(unsigned int)>()\n    VecMat::Vec2<(unsigned int)>(VecMat::Vec2<unsigned int >::value_type const,VecMat::Vec2<unsigned int >::value_type const)\n    VecMat::Vec2<(unsigned int)>(VecMat::Vec2<unsigned int >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int >::value_type)((VecMat::Vec2<unsigned int > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<unsigned int >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec2<unsigned int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2u_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2u_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2u_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_y" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int >::value_type)((VecMat::Vec2<unsigned int > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_y" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<unsigned int >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec2<unsigned int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2u_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2u_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2u_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_setX" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2u_setX" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_setY" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2u_setY" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int > *arg2 = 0 ;
+  VecMat::Vec2<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u___add__" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2u___add__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2u___add__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<unsigned int > const *)arg1)->operator +((VecMat::Vec2<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<unsigned int >(static_cast< const VecMat::Vec2<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int > *arg2 = 0 ;
+  VecMat::Vec2<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u___sub__" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2u___sub__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2u___sub__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<unsigned int > const *)arg1)->operator -((VecMat::Vec2<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<unsigned int >(static_cast< const VecMat::Vec2<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type arg2 ;
+  VecMat::Vec2<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u___mul__" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2u___mul__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<unsigned int > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<unsigned int >(static_cast< const VecMat::Vec2<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int >::value_type arg2 ;
+  VecMat::Vec2<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u___div__" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2u___div__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<unsigned int > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<unsigned int >(static_cast< const VecMat::Vec2<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  VecMat::Vec2<unsigned int > *arg2 = 0 ;
+  VecMat::Vec2<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u___mul__" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2u___mul__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2u___mul__" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec2<unsigned int >::value_type)((VecMat::Vec2<unsigned int > const *)arg1)->operator *((VecMat::Vec2<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2u___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec2u___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec2u___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec2u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec2u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec2u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec2i__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec2i")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec2<int > *)new VecMat::Vec2<int >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2i__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int >::value_type arg1 ;
+  VecMat::Vec2<int >::value_type arg2 ;
+  VecMat::Vec2<int > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec2i",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2i" "', argument " "1"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2i" "', argument " "2"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<int >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec2<int > *)new VecMat::Vec2<int >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2i__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int >::value_type arg1 ;
+  VecMat::Vec2<int > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec2i",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2i" "', argument " "1"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<int >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec2<int > *)new VecMat::Vec2<int >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2i(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec2i__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec2i__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec2i__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2i'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec2<(int)>()\n    VecMat::Vec2<(int)>(VecMat::Vec2<int >::value_type const,VecMat::Vec2<int >::value_type const)\n    VecMat::Vec2<(int)>(VecMat::Vec2<int >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2i_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_x" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<int >::value_type)((VecMat::Vec2<int > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2i_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_x" "', argument " "1"" of type '" "VecMat::Vec2<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<int >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec2<int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2i_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2i_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2i_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2i_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_y" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<int >::value_type)((VecMat::Vec2<int > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2i_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_y" "', argument " "1"" of type '" "VecMat::Vec2<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<int >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec2<int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2i_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2i_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2i_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_setX" "', argument " "1"" of type '" "VecMat::Vec2<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2i_setX" "', argument " "2"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i_setY" "', argument " "1"" of type '" "VecMat::Vec2<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2i_setY" "', argument " "2"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int > *arg2 = 0 ;
+  VecMat::Vec2<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i___add__" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2i___add__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2i___add__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<int > const *)arg1)->operator +((VecMat::Vec2<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<int >(static_cast< const VecMat::Vec2<int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int > *arg2 = 0 ;
+  VecMat::Vec2<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i___sub__" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2i___sub__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2i___sub__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<int > const *)arg1)->operator -((VecMat::Vec2<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<int >(static_cast< const VecMat::Vec2<int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type arg2 ;
+  VecMat::Vec2<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i___mul__" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2i___mul__" "', argument " "2"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<int > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<int >(static_cast< const VecMat::Vec2<int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int >::value_type arg2 ;
+  VecMat::Vec2<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i___div__" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2i___div__" "', argument " "2"" of type '" "VecMat::Vec2<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<int > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<int >(static_cast< const VecMat::Vec2<int >& >(result))), SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  VecMat::Vec2<int > *arg2 = 0 ;
+  VecMat::Vec2<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2i___mul__" "', argument " "1"" of type '" "VecMat::Vec2<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2i___mul__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2i___mul__" "', argument " "2"" of type '" "VecMat::Vec2<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<int > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec2<int >::value_type)((VecMat::Vec2<int > const *)arg1)->operator *((VecMat::Vec2<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2i___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec2i___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec2i___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec2i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<int > *arg1 = (VecMat::Vec2<int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec2i",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec2i" "', argument " "1"" of type '" "VecMat::Vec2<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec2i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec2Tint_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec2f__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec2f")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec2<float > *)new VecMat::Vec2<float >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2f__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float >::value_type arg1 ;
+  VecMat::Vec2<float >::value_type arg2 ;
+  VecMat::Vec2<float > *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec2f",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2f" "', argument " "1"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<float >::value_type >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2f" "', argument " "2"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<float >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec2<float > *)new VecMat::Vec2<float >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2f__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float >::value_type arg1 ;
+  VecMat::Vec2<float > *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec2f",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2f" "', argument " "1"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<float >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec2<float > *)new VecMat::Vec2<float >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2f(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec2f__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec2f__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec2f__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2f'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec2<(float)>()\n    VecMat::Vec2<(float)>(VecMat::Vec2<float >::value_type const,VecMat::Vec2<float >::value_type const)\n    VecMat::Vec2<(float)>(VecMat::Vec2<float >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2f_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_x" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<float >::value_type)((VecMat::Vec2<float > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2f_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_x" "', argument " "1"" of type '" "VecMat::Vec2<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<float >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec2<float >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2f_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2f_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2f_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2f_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_y" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<float >::value_type)((VecMat::Vec2<float > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2f_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_y" "', argument " "1"" of type '" "VecMat::Vec2<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<float >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec2<float >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2f_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2f_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2f_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_setX" "', argument " "1"" of type '" "VecMat::Vec2<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2f_setX" "', argument " "2"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<float >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f_setY" "', argument " "1"" of type '" "VecMat::Vec2<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2f_setY" "', argument " "2"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<float >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float > *arg2 = 0 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f___add__" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2f___add__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2f___add__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<float > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<float > const *)arg1)->operator +((VecMat::Vec2<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float > *arg2 = 0 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f___sub__" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2f___sub__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2f___sub__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<float > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<float > const *)arg1)->operator -((VecMat::Vec2<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type arg2 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f___mul__" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2f___mul__" "', argument " "2"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<float >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<float > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float >::value_type arg2 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f___div__" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2f___div__" "', argument " "2"" of type '" "VecMat::Vec2<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<float >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<float > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  VecMat::Vec2<float > *arg2 = 0 ;
+  VecMat::Vec2<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2f___mul__" "', argument " "1"" of type '" "VecMat::Vec2<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2f___mul__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2f___mul__" "', argument " "2"" of type '" "VecMat::Vec2<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<float > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec2<float >::value_type)((VecMat::Vec2<float > const *)arg1)->operator *((VecMat::Vec2<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2f___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec2f___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec2f___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<float > *arg1 = (VecMat::Vec2<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec2f" "', argument " "1"" of type '" "VecMat::Vec2<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<float > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec2d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec2d")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec2<double > *)new VecMat::Vec2<double >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double >::value_type arg1 ;
+  VecMat::Vec2<double >::value_type arg2 ;
+  VecMat::Vec2<double > *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec2d",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2d" "', argument " "1"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<double >::value_type >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2d" "', argument " "2"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<double >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec2<double > *)new VecMat::Vec2<double >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2d__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double >::value_type arg1 ;
+  VecMat::Vec2<double > *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec2d",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2d" "', argument " "1"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec2<double >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec2<double > *)new VecMat::Vec2<double >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec2d(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec2d__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec2d__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec2d__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2d'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec2<(double)>()\n    VecMat::Vec2<(double)>(VecMat::Vec2<double >::value_type const,VecMat::Vec2<double >::value_type const)\n    VecMat::Vec2<(double)>(VecMat::Vec2<double >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2d_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_x" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<double >::value_type)((VecMat::Vec2<double > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2d_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_x" "', argument " "1"" of type '" "VecMat::Vec2<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<double >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec2<double >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2d_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2d_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2d_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2d_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_y" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec2<double >::value_type)((VecMat::Vec2<double > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec2d_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_y" "', argument " "1"" of type '" "VecMat::Vec2<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec2<double >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec2<double >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2d_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec2d_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2d_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_setX" "', argument " "1"" of type '" "VecMat::Vec2<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2d_setX" "', argument " "2"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<double >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d_setY" "', argument " "1"" of type '" "VecMat::Vec2<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2d_setY" "', argument " "2"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<double >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double > *arg2 = 0 ;
+  VecMat::Vec2<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d___add__" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2d___add__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2d___add__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<double > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<double > const *)arg1)->operator +((VecMat::Vec2<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<double >(static_cast< const VecMat::Vec2<double >& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double > *arg2 = 0 ;
+  VecMat::Vec2<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d___sub__" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2d___sub__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2d___sub__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<double > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec2<double > const *)arg1)->operator -((VecMat::Vec2<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<double >(static_cast< const VecMat::Vec2<double >& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type arg2 ;
+  VecMat::Vec2<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d___mul__" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2d___mul__" "', argument " "2"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<double >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<double > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<double >(static_cast< const VecMat::Vec2<double >& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double >::value_type arg2 ;
+  VecMat::Vec2<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d___div__" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec2d___div__" "', argument " "2"" of type '" "VecMat::Vec2<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec2<double >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec2<double > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<double >(static_cast< const VecMat::Vec2<double >& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  VecMat::Vec2<double > *arg2 = 0 ;
+  VecMat::Vec2<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec2d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2d___mul__" "', argument " "1"" of type '" "VecMat::Vec2<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec2d___mul__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec2d___mul__" "', argument " "2"" of type '" "VecMat::Vec2<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec2<double > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec2<double >::value_type)((VecMat::Vec2<double > const *)arg1)->operator *((VecMat::Vec2<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec2d___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec2d___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec2d___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec2<double > *arg1 = (VecMat::Vec2<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec2d" "', argument " "1"" of type '" "VecMat::Vec2<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec2<double > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_3u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_3u")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,3 > *)new VecMat::Vec<unsigned int,3 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_3u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_3u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_3u" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_3u_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<unsigned int,3 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3u_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u_norm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,3 >::value_type)((VecMat::Vec<unsigned int,3 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3u_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,3 >::value_type)((VecMat::Vec<unsigned int,3 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3u_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u_normalize" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<unsigned int,3 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<unsigned int,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3u_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<unsigned int,3 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<unsigned int,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___add__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,3 > const *)arg1)->operator +((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,3 >(static_cast< const VecMat::Vec<unsigned int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___sub__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,3 > const *)arg1)->operator -((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,3 >(static_cast< const VecMat::Vec<unsigned int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 >::value_type arg2 ;
+  VecMat::Vec<unsigned int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<unsigned int,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,3 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,3 >(static_cast< const VecMat::Vec<unsigned int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 >::value_type arg2 ;
+  VecMat::Vec<unsigned int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___div__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3u___div__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<unsigned int,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<unsigned int,3 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,3 >(static_cast< const VecMat::Vec<unsigned int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  VecMat::Vec<unsigned int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<unsigned int,3 >::value_type)((VecMat::Vec<unsigned int,3 > const *)arg1)->operator *((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_3u___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_3u___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___eq__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,3 > const *)arg1)->operator ==((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___ne__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,3 > const *)arg1)->operator !=((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___lt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,3 > const *)arg1)->operator <((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3u___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<unsigned int,3 > *arg1 = (VecMat::Vec<unsigned int,3 > *) 0 ;
+  VecMat::Vec<unsigned int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3u___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3u___gt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<unsigned int,3 > const *)arg1)->operator >((VecMat::Vec<unsigned int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_3u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTunsigned_int_3_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_3i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_3i")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<int,3 > *)new VecMat::Vec<int,3 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_3i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_3i",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_3i" "', argument " "1"" of type '" "VecMat::Vec<int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_3i_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<int,3 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3i_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i_norm" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<int,3 >::value_type)((VecMat::Vec<int,3 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3i_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<int,3 >::value_type)((VecMat::Vec<int,3 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3i_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i_normalize" "', argument " "1"" of type '" "VecMat::Vec<int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<int,3 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<int,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3i_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<int,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<int,3 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<int,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  VecMat::Vec<int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___add__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<int,3 > const *)arg1)->operator +((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,3 >(static_cast< const VecMat::Vec<int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  VecMat::Vec<int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___sub__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<int,3 > const *)arg1)->operator -((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,3 >(static_cast< const VecMat::Vec<int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 >::value_type arg2 ;
+  VecMat::Vec<int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<int,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<int,3 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,3 >(static_cast< const VecMat::Vec<int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 >::value_type arg2 ;
+  VecMat::Vec<int,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___div__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3i___div__" "', argument " "2"" of type '" "VecMat::Vec<int,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<int,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<int,3 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,3 >(static_cast< const VecMat::Vec<int,3 >& >(result))), SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  VecMat::Vec<int,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<int,3 >::value_type)((VecMat::Vec<int,3 > const *)arg1)->operator *((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTint_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTint_3_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_3i___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTint_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_3i___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___eq__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,3 > const *)arg1)->operator ==((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___ne__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,3 > const *)arg1)->operator !=((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___lt__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,3 > const *)arg1)->operator <((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3i___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<int,3 > *arg1 = (VecMat::Vec<int,3 > *) 0 ;
+  VecMat::Vec<int,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3i___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3i___gt__" "', argument " "1"" of type '" "VecMat::Vec<int,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<int,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<int,3 > const *)arg1)->operator >((VecMat::Vec<int,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_3i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTint_3_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_3d")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<double,3 > *)new VecMat::Vec<double,3 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_3d" "', argument " "1"" of type '" "VecMat::Vec<double,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_3d_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<double,3 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3d_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d_norm" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<double,3 >::value_type)((VecMat::Vec<double,3 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3d_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<double,3 >::value_type)((VecMat::Vec<double,3 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3d_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d_normalize" "', argument " "1"" of type '" "VecMat::Vec<double,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<double,3 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<double,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3d_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<double,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<double,3 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<double,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  VecMat::Vec<double,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___add__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<double,3 > const *)arg1)->operator +((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,3 >(static_cast< const VecMat::Vec<double,3 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  VecMat::Vec<double,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___sub__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<double,3 > const *)arg1)->operator -((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,3 >(static_cast< const VecMat::Vec<double,3 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 >::value_type arg2 ;
+  VecMat::Vec<double,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<double,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<double,3 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,3 >(static_cast< const VecMat::Vec<double,3 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 >::value_type arg2 ;
+  VecMat::Vec<double,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___div__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3d___div__" "', argument " "2"" of type '" "VecMat::Vec<double,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<double,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<double,3 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,3 >(static_cast< const VecMat::Vec<double,3 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  VecMat::Vec<double,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<double,3 >::value_type)((VecMat::Vec<double,3 > const *)arg1)->operator *((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTdouble_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTdouble_3_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_3d___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTdouble_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_3d___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___eq__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,3 > const *)arg1)->operator ==((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___ne__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,3 > const *)arg1)->operator !=((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___lt__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,3 > const *)arg1)->operator <((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3d___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<double,3 > *arg1 = (VecMat::Vec<double,3 > *) 0 ;
+  VecMat::Vec<double,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3d___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3d___gt__" "', argument " "1"" of type '" "VecMat::Vec<double,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<double,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<double,3 > const *)arg1)->operator >((VecMat::Vec<double,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTdouble_3_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec_3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec_3f")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec<float,3 > *)new VecMat::Vec<float,3 >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec_3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_3f" "', argument " "1"" of type '" "VecMat::Vec<float,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Vec_3f_dim")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)VecMat::Vec<float,3 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3f_norm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f_norm" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<float,3 >::value_type)((VecMat::Vec<float,3 > const *)arg1)->norm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3f_squareNorm",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec<float,3 >::value_type)((VecMat::Vec<float,3 > const *)arg1)->squareNorm();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3f_normalize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f_normalize" "', argument " "1"" of type '" "VecMat::Vec<float,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<float,3 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec<float,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec_3f_normalizeSafe",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<float,3 > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec<float,3 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec<float,3 > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  VecMat::Vec<float,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___add__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<float,3 > const *)arg1)->operator +((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,3 >(static_cast< const VecMat::Vec<float,3 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  VecMat::Vec<float,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___sub__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec<float,3 > const *)arg1)->operator -((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,3 >(static_cast< const VecMat::Vec<float,3 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 >::value_type arg2 ;
+  VecMat::Vec<float,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<float,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<float,3 > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,3 >(static_cast< const VecMat::Vec<float,3 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 >::value_type arg2 ;
+  VecMat::Vec<float,3 > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___div__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_3f___div__" "', argument " "2"" of type '" "VecMat::Vec<float,3 >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec<float,3 >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec<float,3 > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,3 >(static_cast< const VecMat::Vec<float,3 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  VecMat::Vec<float,3 >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec<float,3 >::value_type)((VecMat::Vec<float,3 > const *)arg1)->operator *((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTfloat_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTfloat_3_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec_3f___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTfloat_3_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec_3f___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___eq__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,3 > const *)arg1)->operator ==((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___ne__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,3 > const *)arg1)->operator !=((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___lt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___lt__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,3 > const *)arg1)->operator <((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec_3f___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec<float,3 > *arg1 = (VecMat::Vec<float,3 > *) 0 ;
+  VecMat::Vec<float,3 > *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec_3f___gt__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_3_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_3f___gt__" "', argument " "1"" of type '" "VecMat::Vec<float,3 > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_3_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_3f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_3f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,3 > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec<float,3 > * >(argp2);
+  {
+    try {
+      result = (bool)((VecMat::Vec<float,3 > const *)arg1)->operator >((VecMat::Vec<float,3 > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec_3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTfloat_3_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec3u__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec3u")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int > *)new VecMat::Vec3<unsigned int >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3u__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int >::value_type arg1 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  VecMat::Vec3<unsigned int >::value_type arg3 ;
+  VecMat::Vec3<unsigned int > *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vec3u",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3u" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3u" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec3u" "', argument " "3"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg3 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val3);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int > *)new VecMat::Vec3<unsigned int >(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3u__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int >::value_type arg1 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  VecMat::Vec3<unsigned int > *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec3u",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3u" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3u" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int > *)new VecMat::Vec3<unsigned int >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3u__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int >::value_type arg1 ;
+  VecMat::Vec3<unsigned int > *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec3u",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3u" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int > *)new VecMat::Vec3<unsigned int >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3u(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec3u__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec3u__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec3u__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Vec3u__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec3u'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec3<(unsigned int)>()\n    VecMat::Vec3<(unsigned int)>(VecMat::Vec3<unsigned int >::value_type const,VecMat::Vec3<unsigned int >::value_type const,VecMat::Vec3<unsigned int >::value_type const)\n    VecMat::Vec3<(unsigned int)>(VecMat::Vec3<unsigned int >::value_type const,VecMat::Vec3<unsigned int >::value_type const)\n    VecMat::Vec3<(unsigned int)>(VecMat::Vec3<unsigned int >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_x" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int >::value_type)((VecMat::Vec3<unsigned int > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_x" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<unsigned int >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec3<unsigned int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3u_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_y" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int >::value_type)((VecMat::Vec3<unsigned int > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_y" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<unsigned int >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec3<unsigned int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3u_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_z__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_z" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int >::value_type)((VecMat::Vec3<unsigned int > const *)arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_z__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3u_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_z" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<unsigned int >::value_type &_result_ref = (arg1)->z();
+        result = (VecMat::Vec3<unsigned int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_z(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_z__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3u_z__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3u_z'.\n  Possible C/C++ prototypes are:\n    z()\n    z()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_setX" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3u_setX" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_setY" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3u_setY" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u_setZ",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u_setZ" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3u_setZ" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setZ(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int > *arg2 = 0 ;
+  VecMat::Vec3<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___add__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3u___add__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3u___add__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<unsigned int > const *)arg1)->operator +((VecMat::Vec3<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<unsigned int >(static_cast< const VecMat::Vec3<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int > *arg2 = 0 ;
+  VecMat::Vec3<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___sub__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3u___sub__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3u___sub__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<unsigned int > const *)arg1)->operator -((VecMat::Vec3<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<unsigned int >(static_cast< const VecMat::Vec3<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  VecMat::Vec3<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___mul__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3u___mul__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<unsigned int > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<unsigned int >(static_cast< const VecMat::Vec3<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int >::value_type arg2 ;
+  VecMat::Vec3<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___div__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3u___div__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<unsigned int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<unsigned int > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<unsigned int >(static_cast< const VecMat::Vec3<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int > *arg2 = 0 ;
+  VecMat::Vec3<unsigned int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___mul__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3u___mul__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3u___mul__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec3<unsigned int >::value_type)((VecMat::Vec3<unsigned int > const *)arg1)->operator *((VecMat::Vec3<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec3u___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec3u___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3u___xor__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  VecMat::Vec3<unsigned int > *arg2 = 0 ;
+  VecMat::Vec3<unsigned int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3u___xor__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3u___xor__" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3u___xor__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3u___xor__" "', argument " "2"" of type '" "VecMat::Vec3<unsigned int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<unsigned int > const *)arg1)->operator ^((VecMat::Vec3<unsigned int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<unsigned int >(static_cast< const VecMat::Vec3<unsigned int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec3u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<unsigned int > *arg1 = (VecMat::Vec3<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec3u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec3u" "', argument " "1"" of type '" "VecMat::Vec3<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<unsigned int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec3u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec3i__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec3i")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec3<int > *)new VecMat::Vec3<int >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3i__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int >::value_type arg1 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  VecMat::Vec3<int >::value_type arg3 ;
+  VecMat::Vec3<int > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vec3i",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3i" "', argument " "1"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3i" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec3i" "', argument " "3"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg3 = static_cast< VecMat::Vec3<int >::value_type >(val3);
+  {
+    try {
+      result = (VecMat::Vec3<int > *)new VecMat::Vec3<int >(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3i__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int >::value_type arg1 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  VecMat::Vec3<int > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec3i",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3i" "', argument " "1"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<int >::value_type >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3i" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec3<int > *)new VecMat::Vec3<int >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3i__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int >::value_type arg1 ;
+  VecMat::Vec3<int > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec3i",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3i" "', argument " "1"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<int >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec3<int > *)new VecMat::Vec3<int >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3i(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec3i__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec3i__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec3i__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Vec3i__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec3i'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec3<(int)>()\n    VecMat::Vec3<(int)>(VecMat::Vec3<int >::value_type const,VecMat::Vec3<int >::value_type const,VecMat::Vec3<int >::value_type const)\n    VecMat::Vec3<(int)>(VecMat::Vec3<int >::value_type const,VecMat::Vec3<int >::value_type const)\n    VecMat::Vec3<(int)>(VecMat::Vec3<int >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_x" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<int >::value_type)((VecMat::Vec3<int > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_x" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<int >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec3<int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3i_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_y" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<int >::value_type)((VecMat::Vec3<int > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_y" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<int >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec3<int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3i_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_z__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_z" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<int >::value_type)((VecMat::Vec3<int > const *)arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_z__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3i_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_z" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<int >::value_type &_result_ref = (arg1)->z();
+        result = (VecMat::Vec3<int >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_z(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_z__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3i_z__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3i_z'.\n  Possible C/C++ prototypes are:\n    z()\n    z()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_setX" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3i_setX" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_setY" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3i_setY" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i_setZ",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i_setZ" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3i_setZ" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      (arg1)->setZ(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int > *arg2 = 0 ;
+  VecMat::Vec3<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___add__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3i___add__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3i___add__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<int > const *)arg1)->operator +((VecMat::Vec3<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<int >(static_cast< const VecMat::Vec3<int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int > *arg2 = 0 ;
+  VecMat::Vec3<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___sub__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3i___sub__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3i___sub__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<int > const *)arg1)->operator -((VecMat::Vec3<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<int >(static_cast< const VecMat::Vec3<int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  VecMat::Vec3<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___mul__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3i___mul__" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<int > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<int >(static_cast< const VecMat::Vec3<int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int >::value_type arg2 ;
+  VecMat::Vec3<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___div__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3i___div__" "', argument " "2"" of type '" "VecMat::Vec3<int >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<int >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<int > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<int >(static_cast< const VecMat::Vec3<int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int > *arg2 = 0 ;
+  VecMat::Vec3<int >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___mul__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3i___mul__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3i___mul__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<int > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec3<int >::value_type)((VecMat::Vec3<int > const *)arg1)->operator *((VecMat::Vec3<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec3i___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tint_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec3i___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3i___xor__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  VecMat::Vec3<int > *arg2 = 0 ;
+  VecMat::Vec3<int > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3i___xor__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3i___xor__" "', argument " "1"" of type '" "VecMat::Vec3<int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tint_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3i___xor__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3i___xor__" "', argument " "2"" of type '" "VecMat::Vec3<int > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<int > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<int > const *)arg1)->operator ^((VecMat::Vec3<int > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<int >(static_cast< const VecMat::Vec3<int >& >(result))), SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec3i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<int > *arg1 = (VecMat::Vec3<int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec3i",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec3i" "', argument " "1"" of type '" "VecMat::Vec3<int > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec3i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec3Tint_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec3f__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec3f")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec3<float > *)new VecMat::Vec3<float >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3f__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float >::value_type arg1 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  VecMat::Vec3<float >::value_type arg3 ;
+  VecMat::Vec3<float > *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vec3f",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3f" "', argument " "1"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<float >::value_type >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3f" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec3f" "', argument " "3"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg3 = static_cast< VecMat::Vec3<float >::value_type >(val3);
+  {
+    try {
+      result = (VecMat::Vec3<float > *)new VecMat::Vec3<float >(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3f__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float >::value_type arg1 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  VecMat::Vec3<float > *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec3f",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3f" "', argument " "1"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<float >::value_type >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3f" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec3<float > *)new VecMat::Vec3<float >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3f__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float >::value_type arg1 ;
+  VecMat::Vec3<float > *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec3f",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3f" "', argument " "1"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<float >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec3<float > *)new VecMat::Vec3<float >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3f(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec3f__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec3f__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec3f__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Vec3f__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec3f'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec3<(float)>()\n    VecMat::Vec3<(float)>(VecMat::Vec3<float >::value_type const,VecMat::Vec3<float >::value_type const,VecMat::Vec3<float >::value_type const)\n    VecMat::Vec3<(float)>(VecMat::Vec3<float >::value_type const,VecMat::Vec3<float >::value_type const)\n    VecMat::Vec3<(float)>(VecMat::Vec3<float >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_x" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<float >::value_type)((VecMat::Vec3<float > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_x" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<float >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec3<float >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3f_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_y" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<float >::value_type)((VecMat::Vec3<float > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_y" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<float >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec3<float >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3f_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_z__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_z" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<float >::value_type)((VecMat::Vec3<float > const *)arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_z__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3f_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_z" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<float >::value_type &_result_ref = (arg1)->z();
+        result = (VecMat::Vec3<float >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_z(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_z__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3f_z__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3f_z'.\n  Possible C/C++ prototypes are:\n    z()\n    z()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_setX" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3f_setX" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_setY" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3f_setY" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f_setZ",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f_setZ" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3f_setZ" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      (arg1)->setZ(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float > *arg2 = 0 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___add__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3f___add__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3f___add__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<float > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<float > const *)arg1)->operator +((VecMat::Vec3<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float > *arg2 = 0 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___sub__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3f___sub__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3f___sub__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<float > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<float > const *)arg1)->operator -((VecMat::Vec3<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___mul__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3f___mul__" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<float > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float >::value_type arg2 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___div__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3f___div__" "', argument " "2"" of type '" "VecMat::Vec3<float >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<float >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<float > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float > *arg2 = 0 ;
+  VecMat::Vec3<float >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___mul__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3f___mul__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3f___mul__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<float > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec3<float >::value_type)((VecMat::Vec3<float > const *)arg1)->operator *((VecMat::Vec3<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec3f___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec3f___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3f___xor__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  VecMat::Vec3<float > *arg2 = 0 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3f___xor__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3f___xor__" "', argument " "1"" of type '" "VecMat::Vec3<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3f___xor__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3f___xor__" "', argument " "2"" of type '" "VecMat::Vec3<float > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<float > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<float > const *)arg1)->operator ^((VecMat::Vec3<float > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<float > *arg1 = (VecMat::Vec3<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec3f" "', argument " "1"" of type '" "VecMat::Vec3<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<float > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Vec3d__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Vec3d")) SWIG_fail;
+  {
+    try {
+      result = (VecMat::Vec3<double > *)new VecMat::Vec3<double >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3d__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double >::value_type arg1 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  VecMat::Vec3<double >::value_type arg3 ;
+  VecMat::Vec3<double > *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vec3d",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3d" "', argument " "1"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<double >::value_type >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3d" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec3d" "', argument " "3"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg3 = static_cast< VecMat::Vec3<double >::value_type >(val3);
+  {
+    try {
+      result = (VecMat::Vec3<double > *)new VecMat::Vec3<double >(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3d__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double >::value_type arg1 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  VecMat::Vec3<double > *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec3d",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3d" "', argument " "1"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<double >::value_type >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec3d" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      result = (VecMat::Vec3<double > *)new VecMat::Vec3<double >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3d__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double >::value_type arg1 ;
+  VecMat::Vec3<double > *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec3d",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec3d" "', argument " "1"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg1 = static_cast< VecMat::Vec3<double >::value_type >(val1);
+  {
+    try {
+      result = (VecMat::Vec3<double > *)new VecMat::Vec3<double >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Vec3d(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Vec3d__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Vec3d__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_Vec3d__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Vec3d__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec3d'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec3<(double)>()\n    VecMat::Vec3<(double)>(VecMat::Vec3<double >::value_type const,VecMat::Vec3<double >::value_type const,VecMat::Vec3<double >::value_type const)\n    VecMat::Vec3<(double)>(VecMat::Vec3<double >::value_type const,VecMat::Vec3<double >::value_type const)\n    VecMat::Vec3<(double)>(VecMat::Vec3<double >::value_type const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_x" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<double >::value_type)((VecMat::Vec3<double > const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_x" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<double >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec3<double >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_x(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_x__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_x__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3d_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_y" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<double >::value_type)((VecMat::Vec3<double > const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_y" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<double >::value_type &_result_ref = (arg1)->y();
+        result = (VecMat::Vec3<double >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_y(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_y__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_y__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3d_y'.\n  Possible C/C++ prototypes are:\n    y()\n    y()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_z__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_z" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      result = (VecMat::Vec3<double >::value_type)((VecMat::Vec3<double > const *)arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_z__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Vec3d_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_z" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      {
+        VecMat::Vec3<double >::value_type &_result_ref = (arg1)->z();
+        result = (VecMat::Vec3<double >::value_type *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_z(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_z__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Vec3d_z__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec3d_z'.\n  Possible C/C++ prototypes are:\n    z()\n    z()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_setX" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3d_setX" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_setY" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3d_setY" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d_setZ",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d_setZ" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3d_setZ" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      (arg1)->setZ(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double > *arg2 = 0 ;
+  VecMat::Vec3<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___add__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___add__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3d___add__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3d___add__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<double > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<double > const *)arg1)->operator +((VecMat::Vec3<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<double >(static_cast< const VecMat::Vec3<double >& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double > *arg2 = 0 ;
+  VecMat::Vec3<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___sub__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___sub__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3d___sub__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3d___sub__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<double > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<double > const *)arg1)->operator -((VecMat::Vec3<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<double >(static_cast< const VecMat::Vec3<double >& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  VecMat::Vec3<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___mul__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3d___mul__" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<double > const *)arg1)->operator *(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<double >(static_cast< const VecMat::Vec3<double >& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double >::value_type arg2 ;
+  VecMat::Vec3<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___div__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___div__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec3d___div__" "', argument " "2"" of type '" "VecMat::Vec3<double >::value_type""'");
+  } 
+  arg2 = static_cast< VecMat::Vec3<double >::value_type >(val2);
+  {
+    try {
+      result = ((VecMat::Vec3<double > const *)arg1)->operator /(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<double >(static_cast< const VecMat::Vec3<double >& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double > *arg2 = 0 ;
+  VecMat::Vec3<double >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___mul__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___mul__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3d___mul__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3d___mul__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<double > * >(argp2);
+  {
+    try {
+      result = (VecMat::Vec3<double >::value_type)((VecMat::Vec3<double > const *)arg1)->operator *((VecMat::Vec3<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___mul__(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Vec3d___mul____SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Vec3d___mul____SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  Py_INCREF(Py_NotImplemented);
+  return Py_NotImplemented;
+}
+
+
+SWIGINTERN PyObject *_wrap_Vec3d___xor__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  VecMat::Vec3<double > *arg2 = 0 ;
+  VecMat::Vec3<double > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Vec3d___xor__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec3d___xor__" "', argument " "1"" of type '" "VecMat::Vec3<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec3d___xor__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec3d___xor__" "', argument " "2"" of type '" "VecMat::Vec3<double > const &""'"); 
+  }
+  arg2 = reinterpret_cast< VecMat::Vec3<double > * >(argp2);
+  {
+    try {
+      result = ((VecMat::Vec3<double > const *)arg1)->operator ^((VecMat::Vec3<double > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<double >(static_cast< const VecMat::Vec3<double >& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Vec3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  VecMat::Vec3<double > *arg1 = (VecMat::Vec3<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec3d" "', argument " "1"" of type '" "VecMat::Vec3<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< VecMat::Vec3<double > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Vec3d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Noise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Noise")) SWIG_fail;
+  {
+    try {
+      result = (Noise *)new Noise();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Noise, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Noise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Noise",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Noise" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  unsigned int arg5 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Noise_turbulence1",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence1" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Noise_turbulence1" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence1" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence1" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Noise_turbulence1" "', argument " "5"" of type '" "unsigned int""'");
+  } 
+  arg5 = static_cast< unsigned int >(val5);
+  {
+    try {
+      result = (float)(arg1)->turbulence1(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:Noise_turbulence1",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence1" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Noise_turbulence1" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence1" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence1" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      result = (float)(arg1)->turbulence1(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence1(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Noise_turbulence1__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_Noise_turbulence1__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Noise_turbulence1'.\n  Possible C/C++ prototypes are:\n    turbulence1(float,float,float,unsigned int)\n    turbulence1(float,float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  float arg3 ;
+  float arg4 ;
+  unsigned int arg5 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Noise_turbulence2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence2" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_turbulence2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_turbulence2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence2" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence2" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Noise_turbulence2" "', argument " "5"" of type '" "unsigned int""'");
+  } 
+  arg5 = static_cast< unsigned int >(val5);
+  {
+    try {
+      result = (float)(arg1)->turbulence2(*arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  float arg3 ;
+  float arg4 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:Noise_turbulence2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence2" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_turbulence2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_turbulence2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence2" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence2" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      result = (float)(arg1)->turbulence2(*arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence2(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Noise_turbulence2__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_Noise_turbulence2__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Noise_turbulence2'.\n  Possible C/C++ prototypes are:\n    turbulence2(Geometry::Vec2f &,float,float,unsigned int)\n    turbulence2(Geometry::Vec2f &,float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec3f *arg2 = 0 ;
+  float arg3 ;
+  float arg4 ;
+  unsigned int arg5 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  unsigned int val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Noise_turbulence3",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence3" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_turbulence3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_turbulence3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3f * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence3" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence3" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Noise_turbulence3" "', argument " "5"" of type '" "unsigned int""'");
+  } 
+  arg5 = static_cast< unsigned int >(val5);
+  {
+    try {
+      result = (float)(arg1)->turbulence3(*arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec3f *arg2 = 0 ;
+  float arg3 ;
+  float arg4 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:Noise_turbulence3",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_turbulence3" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_turbulence3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_turbulence3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3f * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Noise_turbulence3" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Noise_turbulence3" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      result = (float)(arg1)->turbulence3(*arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_turbulence3(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Noise_turbulence3__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Noise, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_Noise_turbulence3__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Noise_turbulence3'.\n  Possible C/C++ prototypes are:\n    turbulence3(Geometry::Vec3f &,float,float,unsigned int)\n    turbulence3(Geometry::Vec3f &,float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_smoothNoise1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  float arg2 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Noise_smoothNoise1",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_smoothNoise1" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Noise_smoothNoise1" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (float)(arg1)->smoothNoise1(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_smoothNoise2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Noise_smoothNoise2",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_smoothNoise2" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_smoothNoise2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_smoothNoise2" "', argument " "2"" of type '" "Geometry::Vec2f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->smoothNoise2(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Noise_smoothNoise3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Noise *arg1 = (Noise *) 0 ;
+  Geometry::Vec3f *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Noise_smoothNoise3",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Noise, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Noise_smoothNoise3" "', argument " "1"" of type '" "Noise *""'"); 
+  }
+  arg1 = reinterpret_cast< Noise * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Noise_smoothNoise3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Noise_smoothNoise3" "', argument " "2"" of type '" "Geometry::Vec3f &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3f * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->smoothNoise3(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Noise_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Noise, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Material__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Material")) SWIG_fail;
+  {
+    try {
+      result = (Material *)new Material();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Material__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float *arg1 = (float *) 0 ;
+  float *arg2 = (float *) 0 ;
+  float *arg3 = (float *) 0 ;
+  float *arg4 = (float *) 0 ;
+  float arg5 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Material",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Material" "', argument " "1"" of type '" "float const *""'"); 
+  }
+  arg1 = reinterpret_cast< float * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Material" "', argument " "2"" of type '" "float const *""'"); 
+  }
+  arg2 = reinterpret_cast< float * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Material" "', argument " "3"" of type '" "float const *""'"); 
+  }
+  arg3 = reinterpret_cast< float * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_float, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Material" "', argument " "4"" of type '" "float const *""'"); 
+  }
+  arg4 = reinterpret_cast< float * >(argp4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Material" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      result = (Material *)new Material((float const *)arg1,(float const *)arg2,(float const *)arg3,(float const *)arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Material__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = 0 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Material",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Material,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Material" "', argument " "1"" of type '" "Material const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Material" "', argument " "1"" of type '" "Material const &""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (Material *)new Material((Material const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Material(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Material__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Material, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Material__SWIG_2(self, args);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_Material__SWIG_1(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Material'.\n  Possible C/C++ prototypes are:\n    Material()\n    Material(float const *,float const *,float const *,float const *,float const)\n    Material(Material const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Material(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Material",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Material" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_diffuse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_diffuse",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_diffuse" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float *)((Material const *)arg1)->diffuse();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_diffuseR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_diffuseR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_diffuseR" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->diffuseR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_diffuseG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_diffuseG",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_diffuseG" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->diffuseG();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_diffuseB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_diffuseB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_diffuseB" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->diffuseB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_diffuseA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_diffuseA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_diffuseA" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->diffuseA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_specular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_specular",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_specular" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float *)((Material const *)arg1)->specular();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_specularR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_specularR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_specularR" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->specularR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_specularG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_specularG",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_specularG" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->specularG();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_specularB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_specularB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_specularB" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->specularB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_specularA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_specularA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_specularA" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->specularA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_ambient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_ambient",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_ambient" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float *)((Material const *)arg1)->ambient();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_ambientR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_ambientR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_ambientR" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->ambientR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_ambientG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_ambientG",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_ambientG" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->ambientG();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_ambientB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_ambientB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_ambientB" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->ambientB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_ambientA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_ambientA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_ambientA" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->ambientA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_emission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_emission",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_emission" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float *)((Material const *)arg1)->emission();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_emissionR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_emissionR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_emissionR" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->emissionR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_emissionG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_emissionG",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_emissionG" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->emissionG();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_emissionB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_emissionB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_emissionB" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->emissionB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_emissionA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_emissionA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_emissionA" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->emissionA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_shininess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Material_shininess",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_shininess" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  {
+    try {
+      result = (float)((Material const *)arg1)->shininess();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_setDiffuse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Material_setDiffuse",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setDiffuse" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Material_setDiffuse" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Material_setDiffuse" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Material_setDiffuse" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Material_setDiffuse" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_setSpecular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Material_setSpecular",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setSpecular" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Material_setSpecular" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Material_setSpecular" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Material_setSpecular" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Material_setSpecular" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      (arg1)->setSpecular(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_setAmbient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Material_setAmbient",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setAmbient" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Material_setAmbient" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Material_setAmbient" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Material_setAmbient" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Material_setAmbient" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      (arg1)->setAmbient(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_setEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Material_setEmission",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setEmission" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Material_setEmission" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Material_setEmission" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Material_setEmission" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Material_setEmission" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      (arg1)->setEmission(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material_setShininess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Material_setShininess",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setShininess" "', argument " "1"" of type '" "Material *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Material_setShininess" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setShininess(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  Material *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Material___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material___ne__" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Material,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Material___ne__" "', argument " "2"" of type '" "Material const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Material___ne__" "', argument " "2"" of type '" "Material const &""'"); 
+  }
+  arg2 = reinterpret_cast< Material * >(argp2);
+  {
+    try {
+      result = (bool)((Material const *)arg1)->operator !=((Material const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Material___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Material *arg1 = (Material *) 0 ;
+  Material *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Material___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Material, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material___eq__" "', argument " "1"" of type '" "Material const *""'"); 
+  }
+  arg1 = reinterpret_cast< Material * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Material,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Material___eq__" "', argument " "2"" of type '" "Material const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Material___eq__" "', argument " "2"" of type '" "Material const &""'"); 
+  }
+  arg2 = reinterpret_cast< Material * >(argp2);
+  {
+    try {
+      result = (bool)((Material const *)arg1)->operator ==((Material const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Material_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Material, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN int POINT_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable POINT is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *POINT_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::POINT));
+  return pyobj;
+}
+
+
+SWIGINTERN int S_VERTEX_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable S_VERTEX is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *S_VERTEX_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::S_VERTEX));
+  return pyobj;
+}
+
+
+SWIGINTERN int VIEW_VERTEX_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable VIEW_VERTEX is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *VIEW_VERTEX_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::VIEW_VERTEX));
+  return pyobj;
+}
+
+
+SWIGINTERN int NON_T_VERTEX_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable NON_T_VERTEX is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *NON_T_VERTEX_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::NON_T_VERTEX));
+  return pyobj;
+}
+
+
+SWIGINTERN int T_VERTEX_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable T_VERTEX is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *T_VERTEX_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::T_VERTEX));
+  return pyobj;
+}
+
+
+SWIGINTERN int CUSP_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable CUSP is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *CUSP_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::CUSP));
+  return pyobj;
+}
+
+
+SWIGINTERN int NO_FEATURE_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable NO_FEATURE is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *NO_FEATURE_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::NO_FEATURE));
+  return pyobj;
+}
+
+
+SWIGINTERN int SILHOUETTE_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable SILHOUETTE is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *SILHOUETTE_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::SILHOUETTE));
+  return pyobj;
+}
+
+
+SWIGINTERN int BORDER_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable BORDER is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *BORDER_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::BORDER));
+  return pyobj;
+}
+
+
+SWIGINTERN int CREASE_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable CREASE is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *CREASE_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::CREASE));
+  return pyobj;
+}
+
+
+SWIGINTERN int RIDGE_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable RIDGE is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *RIDGE_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::RIDGE));
+  return pyobj;
+}
+
+
+SWIGINTERN int VALLEY_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable VALLEY is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *VALLEY_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::VALLEY));
+  return pyobj;
+}
+
+
+SWIGINTERN int SUGGESTIVE_CONTOUR_set(PyObject *) {
+  SWIG_Error(SWIG_AttributeError,"Variable SUGGESTIVE_CONTOUR is read-only.");
+  return 1;
+}
+
+
+SWIGINTERN PyObject *SUGGESTIVE_CONTOUR_get(void) {
+  PyObject *pyobj = 0;
+  
+  pyobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Nature::SUGGESTIVE_CONTOUR));
+  return pyobj;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Interface0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Interface0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Interface0D" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getExactTypeName" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = ((Interface0D const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getX" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getY" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getZ" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getPoint3D" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = ((Interface0D const *)arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getProjectedX" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getProjectedY" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getProjectedZ" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (real)((Interface0D const *)arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getPoint2D" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = ((Interface0D const *)arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0D_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getFEdge" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0D_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0D_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getId" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = ((Interface0D const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_getNature" "', argument " "1"" of type '" "Interface0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)((Interface0D const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_castToSVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_castToViewVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_castToNonTVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0D_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0D_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0D_castToTVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (TVertex *)(arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Interface0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Interface0D")) SWIG_fail;
+  {
+    try {
+      result = (Interface0D *)new Interface0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Interface0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Interface0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_delete_Interface0DIteratorNested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Interface0DIteratorNested",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Interface0DIteratorNested" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getExactTypeName" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = ((Interface0DIteratorNested const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0D *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getObject" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      {
+        Interface0D &_result_ref = (arg1)->operator *();
+        result = (Interface0D *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0D, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0D *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested___deref__" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (Interface0D *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0D, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_increment" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_decrement" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      (arg1)->decrement();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_isBegin" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (bool)((Interface0DIteratorNested const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_isEnd" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (bool)((Interface0DIteratorNested const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIteratorNested___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested___eq__" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIteratorNested___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIteratorNested___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((Interface0DIteratorNested const *)arg1)->operator ==((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIteratorNested___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested___ne__" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIteratorNested___ne__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIteratorNested___ne__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((Interface0DIteratorNested const *)arg1)->operator !=((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_t",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_t" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (float)((Interface0DIteratorNested const *)arg1)->t();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_u" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (float)((Interface0DIteratorNested const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0DIteratorNested *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_copy" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (Interface0DIteratorNested *)((Interface0DIteratorNested const *)arg1)->copy();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getX" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getY" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getZ" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getPoint3D" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getProjectedX" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getProjectedY" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getProjectedZ" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getPoint2D" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIteratorNested_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getFEdge" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIteratorNested_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIteratorNested_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getId" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_getNature" "', argument " "1"" of type '" "Interface0DIteratorNested const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_castToSVertex" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_castToViewVertex" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_castToNonTVertex" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIteratorNested_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIteratorNested_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIteratorNested_castToTVertex" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Interface0DIteratorNested_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Interface0DIteratorNested, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Interface0DIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIteratorNested *arg1 = (Interface0DIteratorNested *) 0 ;
+  Interface0DIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Interface0DIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIteratorNested, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Interface0DIterator" "', argument " "1"" of type '" "Interface0DIteratorNested *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIteratorNested * >(argp1);
+  {
+    try {
+      result = (Interface0DIterator *)new Interface0DIterator(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Interface0DIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Interface0DIterator")) SWIG_fail;
+  {
+    try {
+      result = (Interface0DIterator *)new Interface0DIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Interface0DIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = 0 ;
+  Interface0DIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Interface0DIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Interface0DIterator" "', argument " "1"" of type '" "Interface0DIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Interface0DIterator" "', argument " "1"" of type '" "Interface0DIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (Interface0DIterator *)new Interface0DIterator((Interface0DIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Interface0DIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Interface0DIterator__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Interface0DIteratorNested, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Interface0DIterator__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Interface0DIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Interface0DIterator__SWIG_2(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Interface0DIterator'.\n  Possible C/C++ prototypes are:\n    Interface0DIterator(Interface0DIteratorNested *)\n    Interface0DIterator()\n    Interface0DIterator(Interface0DIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Interface0DIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Interface0DIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Interface0DIterator" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getExactTypeName" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = ((Interface0DIterator const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Interface0D *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getObject" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      {
+        Interface0D &_result_ref = (arg1)->operator *();
+        result = (Interface0D *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0D, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Interface0D *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator___deref__" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (Interface0D *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface0D, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_increment" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_decrement" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      (arg1)->decrement();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_isBegin" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (bool)((Interface0DIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_isEnd" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (bool)((Interface0DIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator___eq__" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIterator___eq__" "', argument " "2"" of type '" "Interface0DIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIterator___eq__" "', argument " "2"" of type '" "Interface0DIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (bool)((Interface0DIterator const *)arg1)->operator ==((Interface0DIterator const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIterator___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator___ne__" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIterator___ne__" "', argument " "2"" of type '" "Interface0DIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIterator___ne__" "', argument " "2"" of type '" "Interface0DIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (bool)((Interface0DIterator const *)arg1)->operator !=((Interface0DIterator const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_t",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_t" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (float)((Interface0DIterator const *)arg1)->t();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_u" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (float)((Interface0DIterator const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getX" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getY" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getZ" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getPoint3D" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getProjectedX" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getProjectedY" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getProjectedZ" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getPoint2D" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface0DIterator_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getFEdge" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Interface0DIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Interface0DIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getId" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_getNature" "', argument " "1"" of type '" "Interface0DIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_castToSVertex" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_castToViewVertex" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_castToNonTVertex" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface0DIterator_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0DIterator *arg1 = (Interface0DIterator *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface0DIterator_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0DIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface0DIterator_castToTVertex" "', argument " "1"" of type '" "Interface0DIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0DIterator * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Interface0DIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Interface0DIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Interface1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Interface1D")) SWIG_fail;
+  {
+    try {
+      result = (Interface1D *)new Interface1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Interface1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Interface1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Interface1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Interface1D" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_getExactTypeName" "', argument " "1"" of type '" "Interface1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = ((Interface1D const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_verticesBegin" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_verticesEnd" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface1D_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_pointsBegin" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Interface1D_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_pointsBegin" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Interface1D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Interface1D_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Interface1D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Interface1D_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Interface1D_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface1D_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_pointsEnd" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Interface1D_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_pointsEnd" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Interface1D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Interface1D_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Interface1D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Interface1D_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Interface1D_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_getLength2D" "', argument " "1"" of type '" "Interface1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (real)((Interface1D const *)arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_getId" "', argument " "1"" of type '" "Interface1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = ((Interface1D const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_getNature" "', argument " "1"" of type '" "Interface1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (Nature::EdgeNature)((Interface1D const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_getTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Interface1D_getTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_getTimeStamp" "', argument " "1"" of type '" "Interface1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (unsigned int)((Interface1D const *)arg1)->getTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Interface1D_setTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Interface1D_setTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Interface1D_setTimeStamp" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Interface1D_setTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Interface1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Interface1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_integrateUnsigned__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  IntegrationType arg4 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:integrateUnsigned",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTunsigned_int_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateUnsigned" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateUnsigned" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "integrateUnsigned" "', argument " "4"" of type '" "IntegrationType""'");
+  } 
+  arg4 = static_cast< IntegrationType >(val4);
+  {
+    try {
+      result = (unsigned int)integrate<unsigned int >(*arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateUnsigned__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:integrateUnsigned",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTunsigned_int_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateUnsigned" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateUnsigned" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateUnsigned" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      result = (unsigned int)integrate<unsigned int >(*arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateUnsigned(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_integrateUnsigned__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_integrateUnsigned__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'integrateUnsigned'.\n  Possible C/C++ prototypes are:\n    integrate<(unsigned int)>(UnaryFunction0D<unsigned int > &,Interface0DIterator,Interface0DIterator,IntegrationType)\n    integrate<(unsigned int)>(UnaryFunction0D<unsigned int > &,Interface0DIterator,Interface0DIterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateFloat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  IntegrationType arg4 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:integrateFloat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTfloat_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateFloat" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateFloat" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "integrateFloat" "', argument " "4"" of type '" "IntegrationType""'");
+  } 
+  arg4 = static_cast< IntegrationType >(val4);
+  {
+    try {
+      result = (float)integrate<float >(*arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateFloat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:integrateFloat",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTfloat_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateFloat" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateFloat" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateFloat" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      result = (float)integrate<float >(*arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateFloat(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_integrateFloat__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTfloat_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_integrateFloat__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'integrateFloat'.\n  Possible C/C++ prototypes are:\n    integrate<(float)>(UnaryFunction0D<float > &,Interface0DIterator,Interface0DIterator,IntegrationType)\n    integrate<(float)>(UnaryFunction0D<float > &,Interface0DIterator,Interface0DIterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  IntegrationType arg4 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:integrateDouble",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateDouble" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateDouble" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "integrateDouble" "', argument " "4"" of type '" "IntegrationType""'");
+  } 
+  arg4 = static_cast< IntegrationType >(val4);
+  {
+    try {
+      result = (double)integrate<double >(*arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  Interface0DIterator arg2 ;
+  Interface0DIterator arg3 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:integrateDouble",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "integrateDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "integrateDouble" "', argument " "2"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "2"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0DIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "integrateDouble" "', argument " "3"" of type '" "Interface0DIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "integrateDouble" "', argument " "3"" of type '" "Interface0DIterator""'");
+    } else {
+      Interface0DIterator * temp = reinterpret_cast< Interface0DIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      result = (double)integrate<double >(*arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_integrateDouble(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_integrateDouble__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Interface0DIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Interface0DIterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_integrateDouble__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'integrateDouble'.\n  Possible C/C++ prototypes are:\n    integrate<(double)>(UnaryFunction0D<double > &,Interface0DIterator,Interface0DIterator,IntegrationType)\n    integrate<(double)>(UnaryFunction0D<double > &,Interface0DIterator,Interface0DIterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getExactTypeName" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getX" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getY" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getZ" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getPoint3D" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getProjectedX" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getProjectedY" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getProjectedZ" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getPoint2D" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getFEdge" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getId" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getNature" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)((SVertex const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_castToSVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_castToViewVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_castToNonTVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_castToTVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (TVertex *)(arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_userdata_set" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_userdata_get" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_SVertex")) SWIG_fail;
+  {
+    try {
+      result = (SVertex *)new SVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Geometry::Vec3r *arg1 = 0 ;
+  Id *arg2 = 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_SVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SVertex" "', argument " "1"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SVertex" "', argument " "1"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg1 = reinterpret_cast< Geometry::Vec3r * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SVertex" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SVertex" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      result = (SVertex *)new SVertex((Geometry::Vec3r const &)*arg1,(Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_SVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SVertex,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SVertex" "', argument " "1"" of type '" "SVertex &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SVertex" "', argument " "1"" of type '" "SVertex &""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)new SVertex(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVertex(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_SVertex__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_SVertex__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Id, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_SVertex__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SVertex'.\n  Possible C/C++ prototypes are:\n    SVertex()\n    SVertex(Geometry::Vec3r const &,Id const &)\n    SVertex(SVertex &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_duplicate" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex___eq__" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_SVertex,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex___eq__" "', argument " "2"" of type '" "SVertex const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex___eq__" "', argument " "2"" of type '" "SVertex const &""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ==((SVertex const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_point3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_point3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_point3D" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((SVertex const *)arg1)->point3D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_point2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_point2D" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((SVertex const *)arg1)->point2D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_normals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SwigValueWrapper<set<VecMat::Vec3<double > > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_normals",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_normals" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->normals();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new set<Geometry::Vec3r >(static_cast< const set<Geometry::Vec3r >& >(result))), SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_normalsSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_normalsSize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_normalsSize" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (unsigned int)((SVertex const *)arg1)->normalsSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_fedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_fedges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_fedges" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        std::vector<FEdge * > const &_result_ref = (arg1)->fedges();
+        result = (std::vector<FEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_fedges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_fedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_fedges_begin" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->fedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_fedges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_fedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_fedges_end" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->fedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_shape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_shape" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SShape *)(arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_z" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_viewvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_viewvertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_viewvertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->viewvertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setPoint3D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setPoint3D" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setPoint3D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setPoint2D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setPoint2D" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setPoint2D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_AddNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_AddNormal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_AddNormal" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->AddNormal((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  CurvatureInfo *arg2 = (CurvatureInfo *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setCurvatureInfo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setCurvatureInfo" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setCurvatureInfo" "', argument " "2"" of type '" "CurvatureInfo *""'"); 
+  }
+  arg2 = reinterpret_cast< CurvatureInfo * >(argp2);
+  {
+    try {
+      (arg1)->setCurvatureInfo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_getCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  CurvatureInfo *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_getCurvatureInfo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_getCurvatureInfo" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (CurvatureInfo *)((SVertex const *)arg1)->getCurvatureInfo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setCurvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setCurvatureFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setCurvatureFredo" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVertex_setCurvatureFredo" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (arg1)->setCurvatureFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setDirectionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec2r arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setDirectionFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setDirectionFredo" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'");
+    } else {
+      Geometry::Vec2r * temp = reinterpret_cast< Geometry::Vec2r * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    try {
+      (arg1)->setDirectionFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_curvatureFredo" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)(arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec2r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_directionFredo" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2r(static_cast< const Geometry::Vec2r& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setId" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  std::vector<FEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setFEdges",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setFEdges" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVertex_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * > * >(argp2);
+  {
+    try {
+      (arg1)->setFEdges((std::vector<FEdge * > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SShape *arg2 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setShape" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setShape" "', argument " "2"" of type '" "SShape *""'"); 
+  }
+  arg2 = reinterpret_cast< SShape * >(argp2);
+  {
+    try {
+      (arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_setViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_setViewVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_setViewVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_setViewVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->setViewVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_AddFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVertex_AddFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_AddFEdge" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_AddFEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddFEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVertex_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_Replace" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVertex_Replace" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVertex_Replace" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  {
+    try {
+      (arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_fedge" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_point2d" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((SVertex const *)arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_point3d" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((SVertex const *)arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_normal" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_shape_id" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_shape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_shape" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SShape *)((SVertex const *)arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_shape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVertex_shape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVertex_shape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVertex_shape'.\n  Possible C/C++ prototypes are:\n    shape()\n    shape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_shape_importance" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (float)((SVertex const *)arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_qi" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (int)((SVertex const *)arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occluders_begin" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occluders_end" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = ((SVertex const *)arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occluders_empty" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (bool)((SVertex const *)arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occluders_size" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (int)((SVertex const *)arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occludee" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = ((SVertex const *)arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occluded_shape" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SShape *)((SVertex const *)arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_occludee_empty" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (bool)((SVertex const *)arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVertex_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVertex_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVertex_z_discontinuity" "', argument " "1"" of type '" "SVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (real)((SVertex const *)arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_SVertex, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_FEdge_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getExactTypeName" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getLength2D" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (real)((FEdge const *)arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getId" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_userdata_set" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_userdata_get" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FEdge")) SWIG_fail;
+  {
+    try {
+      result = (FEdge *)new FEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdge" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FEdge" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      result = (FEdge *)new FEdge(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FEdge,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdge" "', argument " "1"" of type '" "FEdge &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FEdge" "', argument " "1"" of type '" "FEdge &""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)new FEdge(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdge(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_FEdge__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FEdge__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FEdge__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FEdge'.\n  Possible C/C++ prototypes are:\n    FEdge()\n    FEdge(SVertex *,SVertex *)\n    FEdge(FEdge &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_duplicate" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_vertexA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_vertexA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_vertexA" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->vertexA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_vertexB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_vertexB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_vertexB" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->vertexB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getNature" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (Nature::EdgeNature)((FEdge const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_nextEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_nextEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_nextEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->nextEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_previousEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_previousEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_previousEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->previousEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_shape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_shape" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SShape *)(arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_invisibility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_invisibility",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_invisibility" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (int)((FEdge const *)arg1)->invisibility();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_viewedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_viewedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_viewedge" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)((FEdge const *)arg1)->viewedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_center3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_center3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_center3d" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->center3d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_center2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_center2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_center2d" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->center2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_aFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_aFace",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_aFace" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = ((FEdge const *)arg1)->aFace();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_getOccludeeIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getOccludeeIntersection",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getOccludeeIntersection" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (arg1)->getOccludeeIntersection();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_getOccludeeEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_getOccludeeEmpty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_getOccludeeEmpty" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->getOccludeeEmpty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_isSmooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_isSmooth",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_isSmooth" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (bool)((FEdge const *)arg1)->isSmooth();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setVertexA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setVertexA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setVertexA" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setVertexA" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setVertexA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setVertexB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setVertexB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setVertexB" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setVertexB" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setVertexB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setId" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdge_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setNextEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setNextEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setNextEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setNextEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->setNextEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setPreviousEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setPreviousEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setPreviousEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setPreviousEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->setPreviousEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Nature::EdgeNature arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned short val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setNature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setNature" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdge_setNature" "', argument " "2"" of type '" "Nature::EdgeNature""'");
+  } 
+  arg2 = static_cast< Nature::EdgeNature >(val2);
+  {
+    try {
+      (arg1)->setNature(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setViewEdge" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setaFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Polygon3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setaFace",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setaFace" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Polygon3r,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setaFace" "', argument " "2"" of type '" "Polygon3r &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdge_setaFace" "', argument " "2"" of type '" "Polygon3r &""'"); 
+  }
+  arg2 = reinterpret_cast< Polygon3r * >(argp2);
+  {
+    try {
+      (arg1)->setaFace(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setOccludeeIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setOccludeeIntersection",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setOccludeeIntersection" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_setOccludeeIntersection" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdge_setOccludeeIntersection" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setOccludeeIntersection((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setOccludeeEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setOccludeeEmpty",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setOccludeeEmpty" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdge_setOccludeeEmpty" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->setOccludeeEmpty(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_setSmooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_setSmooth",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_setSmooth" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdge_setSmooth" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->setSmooth(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_CommonVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_CommonVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_CommonVertex" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdge_CommonVertex" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      result = (SVertex *)FEdge::CommonVertex(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_min2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_min2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_min2d" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SVertex *)((FEdge const *)arg1)->min2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_max2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_max2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_max2d" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SVertex *)((FEdge const *)arg1)->max2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_shape_id" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_shape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_shape" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SShape *)((FEdge const *)arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_shape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdge_shape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdge_shape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdge_shape'.\n  Possible C/C++ prototypes are:\n    shape()\n    shape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_shape_importance" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (float)((FEdge const *)arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_qi" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (int)((FEdge const *)arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occluders_begin" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occluders_end" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occluders_empty" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (bool)((FEdge const *)arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occluders_size" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (int)((FEdge const *)arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occludee" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = ((FEdge const *)arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occluded_shape" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (SShape *)((FEdge const *)arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_occludee_empty" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (bool)((FEdge const *)arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_z_discontinuity" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (real)((FEdge const *)arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_viewedge_nature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_viewedge_nature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_viewedge_nature" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (int)((FEdge const *)arg1)->viewedge_nature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_orientation2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_orientation2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_orientation2d" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->orientation2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_orientation3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_orientation3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_orientation3d" "', argument " "1"" of type '" "FEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = ((FEdge const *)arg1)->orientation3d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_verticesBegin" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_verticesEnd" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_pointsBegin" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdge_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_pointsBegin" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdge_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FEdge_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdge_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdge_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_pointsEnd" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdge_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *arg1 = (FEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdge_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdge_pointsEnd" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdge_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdge_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FEdge_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdge_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_FEdge, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSVertexIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FEdgeSVertexIterator")) SWIG_fail;
+  {
+    try {
+      result = (FEdgeInternal::SVertexIterator *)new FEdgeInternal::SVertexIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSVertexIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = 0 ;
+  FEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdgeSVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FEdgeInternal__SVertexIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSVertexIterator" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FEdgeSVertexIterator" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (FEdgeInternal::SVertexIterator *)new FEdgeInternal::SVertexIterator((FEdgeInternal::SVertexIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSVertexIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  FEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FEdgeSVertexIterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSVertexIterator" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FEdgeSVertexIterator" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      result = (FEdgeInternal::SVertexIterator *)new FEdgeInternal::SVertexIterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSVertexIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_FEdgeSVertexIterator__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FEdgeSVertexIterator__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FEdgeSVertexIterator__SWIG_2(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FEdgeSVertexIterator'.\n  Possible C/C++ prototypes are:\n    FEdgeInternal::SVertexIterator()\n    FEdgeInternal::SVertexIterator(FEdgeInternal::SVertexIterator const &)\n    FEdgeInternal::SVertexIterator(SVertex *,FEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getExactTypeName" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = ((FEdgeInternal::SVertexIterator const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getObject" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        SVertex &_result_ref = (arg1)->operator *();
+        result = (SVertex *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator___deref__" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_increment" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_decrement" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->decrement();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_isBegin" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((FEdgeInternal::SVertexIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_isEnd" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((FEdgeInternal::SVertexIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator___eq__" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((FEdgeInternal::SVertexIterator const *)arg1)->operator ==((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_t",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_t" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((FEdgeInternal::SVertexIterator const *)arg1)->t();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_u" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((FEdgeInternal::SVertexIterator const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  FEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_copy" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (FEdgeInternal::SVertexIterator *)((FEdgeInternal::SVertexIterator const *)arg1)->copy();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FEdgeSVertexIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FEdgeSVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FEdgeSVertexIterator" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getX" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getY" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getZ" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getPoint3D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getProjectedX" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getProjectedY" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getProjectedZ" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getPoint2D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getFEdge" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getId" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getNature" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_castToSVertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_castToViewVertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_castToNonTVertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_castToTVertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_userdata_set" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (*arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_userdata_get" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  result = (void *) ((*arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_duplicate" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_point3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_point3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_point3D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_point2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_point2D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_normals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SwigValueWrapper<set<VecMat::Vec3<double > > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_normals",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_normals" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normals();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new set<Geometry::Vec3r >(static_cast< const set<Geometry::Vec3r >& >(result))), SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_normalsSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_normalsSize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_normalsSize" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->normalsSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_fedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_fedges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_fedges" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        std::vector<FEdge * > const &_result_ref = (*arg1)->fedges();
+        result = (std::vector<FEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_fedges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_fedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_fedges_begin" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->fedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_fedges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_fedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_fedges_end" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->fedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_shape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_shape" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_shape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_shape" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_shape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgeSVertexIterator_shape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgeSVertexIterator_shape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgeSVertexIterator_shape'.\n  Possible C/C++ prototypes are:\n    shape()\n    shape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_z" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_viewvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_viewvertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_viewvertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->viewvertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setPoint3D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setPoint3D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->setPoint3D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setPoint2D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setPoint2D" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->setPoint2D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_AddNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_AddNormal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_AddNormal" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->AddNormal((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  CurvatureInfo *arg2 = (CurvatureInfo *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setCurvatureInfo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setCurvatureInfo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setCurvatureInfo" "', argument " "2"" of type '" "CurvatureInfo *""'"); 
+  }
+  arg2 = reinterpret_cast< CurvatureInfo * >(argp2);
+  {
+    try {
+      (*arg1)->setCurvatureInfo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_getCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  CurvatureInfo *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_getCurvatureInfo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_getCurvatureInfo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (CurvatureInfo *)(*arg1)->getCurvatureInfo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setCurvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setCurvatureFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setCurvatureFredo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgeSVertexIterator_setCurvatureFredo" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (*arg1)->setCurvatureFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setDirectionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2r arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setDirectionFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setDirectionFredo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'");
+    } else {
+      Geometry::Vec2r * temp = reinterpret_cast< Geometry::Vec2r * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    try {
+      (*arg1)->setDirectionFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_curvatureFredo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_directionFredo" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2r(static_cast< const Geometry::Vec2r& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setId" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  std::vector<FEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setFEdges",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setFEdges" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSVertexIterator_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * > * >(argp2);
+  {
+    try {
+      (*arg1)->setFEdges((std::vector<FEdge * > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SShape *arg2 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setShape" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setShape" "', argument " "2"" of type '" "SShape *""'"); 
+  }
+  arg2 = reinterpret_cast< SShape * >(argp2);
+  {
+    try {
+      (*arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_setViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_setViewVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_setViewVertex" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_setViewVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setViewVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_AddFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSVertexIterator_AddFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_AddFEdge" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_AddFEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->AddFEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgeSVertexIterator_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_Replace" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSVertexIterator_Replace" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FEdgeSVertexIterator_Replace" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  {
+    try {
+      (*arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_fedge" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_point2d" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_point3d" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_normal" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_shape_id" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_shape_importance" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_qi" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occluders_begin" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occluders_end" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occluders_empty" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occluders_size" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occludee" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occluded_shape" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_occludee_empty" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSVertexIterator_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeInternal::SVertexIterator *arg1 = (FEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSVertexIterator_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSVertexIterator_z_discontinuity" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FEdgeSVertexIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_FEdgeInternal__SVertexIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSharp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FEdgeSharp")) SWIG_fail;
+  {
+    try {
+      result = (FEdgeSharp *)new FEdgeSharp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSharp, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSharp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  FEdgeSharp *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FEdgeSharp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSharp" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FEdgeSharp" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      result = (FEdgeSharp *)new FEdgeSharp(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSharp, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSharp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = 0 ;
+  FEdgeSharp *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdgeSharp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FEdgeSharp,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSharp" "', argument " "1"" of type '" "FEdgeSharp &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FEdgeSharp" "', argument " "1"" of type '" "FEdgeSharp &""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      result = (FEdgeSharp *)new FEdgeSharp(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSharp, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSharp(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_FEdgeSharp__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdgeSharp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FEdgeSharp__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FEdgeSharp__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FEdgeSharp'.\n  Possible C/C++ prototypes are:\n    FEdgeSharp()\n    FEdgeSharp(SVertex *,SVertex *)\n    FEdgeSharp(FEdgeSharp &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FEdgeSharp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FEdgeSharp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FEdgeSharp" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_duplicate" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_normalA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_normalA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_normalA" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (arg1)->normalA();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_normalB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_normalB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_normalB" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (arg1)->normalB();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_aMaterialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_aMaterialIndex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_aMaterialIndex" "', argument " "1"" of type '" "FEdgeSharp const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      result = (unsigned int)((FEdgeSharp const *)arg1)->aMaterialIndex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_aMaterial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_aMaterial",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_aMaterial" "', argument " "1"" of type '" "FEdgeSharp const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      {
+        Material const &_result_ref = ((FEdgeSharp const *)arg1)->aMaterial();
+        result = (Material *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_bMaterialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_bMaterialIndex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_bMaterialIndex" "', argument " "1"" of type '" "FEdgeSharp const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      result = (unsigned int)((FEdgeSharp const *)arg1)->bMaterialIndex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_bMaterial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSharp_bMaterial",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_bMaterial" "', argument " "1"" of type '" "FEdgeSharp const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      {
+        Material const &_result_ref = ((FEdgeSharp const *)arg1)->bMaterial();
+        result = (Material *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_setNormalA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSharp_setNormalA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_setNormalA" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSharp_setNormalA" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSharp_setNormalA" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setNormalA((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_setNormalB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSharp_setNormalB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_setNormalB" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSharp_setNormalB" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSharp_setNormalB" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setNormalB((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_setaMaterialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSharp_setaMaterialIndex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_setaMaterialIndex" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgeSharp_setaMaterialIndex" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setaMaterialIndex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSharp_setbMaterialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSharp *arg1 = (FEdgeSharp *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSharp_setbMaterialIndex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSharp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSharp_setbMaterialIndex" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgeSharp_setbMaterialIndex" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setbMaterialIndex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FEdgeSharp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_FEdgeSharp, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSmooth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FEdgeSmooth")) SWIG_fail;
+  {
+    try {
+      result = (FEdgeSmooth *)new FEdgeSmooth();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSmooth, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSmooth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  FEdgeSmooth *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FEdgeSmooth",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSmooth" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FEdgeSmooth" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      result = (FEdgeSmooth *)new FEdgeSmooth(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSmooth, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSmooth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = 0 ;
+  FEdgeSmooth *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdgeSmooth",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FEdgeSmooth,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgeSmooth" "', argument " "1"" of type '" "FEdgeSmooth &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FEdgeSmooth" "', argument " "1"" of type '" "FEdgeSmooth &""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      result = (FEdgeSmooth *)new FEdgeSmooth(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdgeSmooth, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgeSmooth(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_FEdgeSmooth__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FEdgeSmooth, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FEdgeSmooth__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FEdgeSmooth__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FEdgeSmooth'.\n  Possible C/C++ prototypes are:\n    FEdgeSmooth()\n    FEdgeSmooth(SVertex *,SVertex *)\n    FEdgeSmooth(FEdgeSmooth &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FEdgeSmooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FEdgeSmooth",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FEdgeSmooth" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSmooth_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_duplicate" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_face(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSmooth_face",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_face" "', argument " "1"" of type '" "FEdgeSmooth const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      result = (void *)((FEdgeSmooth const *)arg1)->face();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSmooth_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_normal" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (arg1)->normal();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_materialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSmooth_materialIndex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_materialIndex" "', argument " "1"" of type '" "FEdgeSmooth const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      result = (unsigned int)((FEdgeSmooth const *)arg1)->materialIndex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_material(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgeSmooth_material",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_material" "', argument " "1"" of type '" "FEdgeSmooth const *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      {
+        Material const &_result_ref = ((FEdgeSmooth const *)arg1)->material();
+        result = (Material *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_setFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSmooth_setFace",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_setFace" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSmooth_setFace" "', argument " "2"" of type '" "void *""'"); 
+  }
+  {
+    try {
+      (arg1)->setFace(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_setNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSmooth_setNormal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_setNormal" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgeSmooth_setNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgeSmooth_setNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (arg1)->setNormal((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgeSmooth_setMaterialIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdgeSmooth *arg1 = (FEdgeSmooth *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgeSmooth_setMaterialIndex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FEdgeSmooth, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgeSmooth_setMaterialIndex" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgeSmooth_setMaterialIndex" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setMaterialIndex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FEdgeSmooth_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_FEdgeSmooth, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_SShape_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_userdata_set" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_userdata_get" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_SShape")) SWIG_fail;
+  {
+    try {
+      result = (SShape *)new SShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_SShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SShape,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SShape" "', argument " "1"" of type '" "SShape &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SShape" "', argument " "1"" of type '" "SShape &""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (SShape *)new SShape(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_SShape__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SShape, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_SShape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SShape'.\n  Possible C/C++ prototypes are:\n    SShape()\n    SShape(SShape &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_duplicate" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (SShape *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SShape" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_AddEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_AddEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_AddEdge" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_AddEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_AddNewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_AddNewVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_AddNewVertex" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_AddNewVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->AddNewVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_AddChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_AddChain",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_AddChain" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_AddChain" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddChain(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_CreateSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  Geometry::Vec3r *arg3 = 0 ;
+  Id *arg4 = 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SShape_CreateSVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_CreateSVertex" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_CreateSVertex" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_CreateSVertex" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SShape_CreateSVertex" "', argument " "3"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_CreateSVertex" "', argument " "3"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec3r * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SShape_CreateSVertex" "', argument " "4"" of type '" "Id const &""'"); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_CreateSVertex" "', argument " "4"" of type '" "Id const &""'"); 
+  }
+  arg4 = reinterpret_cast< Id * >(argp4);
+  {
+    try {
+      result = (SVertex *)(arg1)->CreateSVertex((Geometry::Vec3r const &)*arg2,(Geometry::Vec3r const &)*arg3,(Id const &)*arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_SplitEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  std::vector<Geometry::Vec2r > *arg3 = 0 ;
+  std::vector<FEdge * > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SShape_SplitEdge",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_SplitEdge" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_SplitEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SShape_SplitEdge" "', argument " "3"" of type '" "std::vector<Geometry::Vec2r > const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_SplitEdge" "', argument " "3"" of type '" "std::vector<Geometry::Vec2r > const &""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<Geometry::Vec2r > * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SShape_SplitEdge" "', argument " "4"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_SplitEdge" "', argument " "4"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<FEdge * > * >(argp4);
+  {
+    try {
+      (arg1)->SplitEdge(arg2,(std::vector<Geometry::Vec2r > const &)*arg3,*arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_SplitEdgeIn2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  SVertex *arg3 = (SVertex *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SShape_SplitEdgeIn2",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_SplitEdgeIn2" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_SplitEdgeIn2" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SShape_SplitEdgeIn2" "', argument " "3"" of type '" "SVertex *""'"); 
+  }
+  arg3 = reinterpret_cast< SVertex * >(argp3);
+  {
+    try {
+      result = (FEdge *)(arg1)->SplitEdgeIn2(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_setBBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  BBox<Geometry::Vec3r > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_setBBox",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_setBBox" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_setBBox" "', argument " "2"" of type '" "BBox<Geometry::Vec3r > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_setBBox" "', argument " "2"" of type '" "BBox<Geometry::Vec3r > const &""'"); 
+  }
+  arg2 = reinterpret_cast< BBox<Geometry::Vec3r > * >(argp2);
+  {
+    try {
+      (arg1)->setBBox((BBox<Geometry::Vec3r > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_ComputeBBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_ComputeBBox",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_ComputeBBox" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      (arg1)->ComputeBBox();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_RemoveEdgeFromChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_RemoveEdgeFromChain",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_RemoveEdgeFromChain" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_RemoveEdgeFromChain" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->RemoveEdgeFromChain(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_RemoveEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_RemoveEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_RemoveEdge" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_RemoveEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->RemoveEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_GetVertexList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  std::vector<SVertex * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_GetVertexList",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_GetVertexList" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<SVertex * > &_result_ref = (arg1)->GetVertexList();
+        result = (std::vector<SVertex * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_GetEdgeList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_GetEdgeList",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_GetEdgeList" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<FEdge * > &_result_ref = (arg1)->GetEdgeList();
+        result = (std::vector<FEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_GetChains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_GetChains",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_GetChains" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<FEdge * > &_result_ref = (arg1)->GetChains();
+        result = (std::vector<FEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_bbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  BBox<Geometry::Vec3r > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_bbox",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_bbox" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      {
+        BBox<Geometry::Vec3r > const &_result_ref = (arg1)->bbox();
+        result = (BBox<Geometry::Vec3r > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_material(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  unsigned int arg2 ;
+  Material *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_material",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_material" "', argument " "1"" of type '" "SShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SShape_material" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      {
+        Material const &_result_ref = ((SShape const *)arg1)->material(arg2);
+        result = (Material *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Material, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_materials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  std::vector<Material > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_materials",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_materials" "', argument " "1"" of type '" "SShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<Material > const &_result_ref = ((SShape const *)arg1)->materials();
+        result = (std::vector<Material > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTMaterial_std__allocatorTMaterial_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_viewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_viewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_viewShape" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(arg1)->viewShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_importance" "', argument " "1"" of type '" "SShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (float)((SShape const *)arg1)->importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SShape_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_getId" "', argument " "1"" of type '" "SShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = ((SShape const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  Id arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_setId" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_setId" "', argument " "2"" of type '" "Id""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_setId" "', argument " "2"" of type '" "Id""'");
+    } else {
+      Id * temp = reinterpret_cast< Id * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    try {
+      (arg1)->setId(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_setMaterials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  std::vector<Material > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_setMaterials",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_setMaterials" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTMaterial_std__allocatorTMaterial_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_setMaterials" "', argument " "2"" of type '" "std::vector<Material > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SShape_setMaterials" "', argument " "2"" of type '" "std::vector<Material > const &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<Material > * >(argp2);
+  {
+    try {
+      (arg1)->setMaterials((std::vector<Material > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_setViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_setViewShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_setViewShape" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SShape_setViewShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (arg1)->setViewShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SShape_setImportance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SShape_setImportance",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SShape_setImportance" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SShape_setImportance" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setImportance(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_SShape, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_iterator" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_ViewShape_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___nonzero__" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_ViewShape_Sm__Sg____nonzero__((std::vector<ViewShape * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___len__" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_ViewShape_Sm__Sg____len__((std::vector<ViewShape * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_pop" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<ViewShape * >::value_type)std_vector_Sl_ViewShape_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  std::vector<ViewShape * >::difference_type arg3 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___getslice__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___getslice__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewShapesContainer___getslice__" "', argument " "3"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewShape * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<ViewShape *,std::allocator<ViewShape * > > *)std_vector_Sl_ViewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  std::vector<ViewShape * >::difference_type arg3 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewShapesContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___setslice__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___setslice__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewShapesContainer___setslice__" "', argument " "3"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewShape * >::difference_type >(val3);
+  {
+    std::vector<ViewShape*,std::allocator<ViewShape * > > *ptr = (std::vector<ViewShape*,std::allocator<ViewShape * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewShapesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewShape *,std::allocator<ViewShape * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShapesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewShape *,std::allocator<ViewShape * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_ViewShape_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<ViewShape *,std::allocator<ViewShape * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  std::vector<ViewShape * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___delslice__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___delslice__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewShapesContainer___delslice__" "', argument " "3"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewShape * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___delitem__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___delitem__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewShape_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  std::vector<ViewShape * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___getitem__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___getitem__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<ViewShape * >::value_type)std_vector_Sl_ViewShape_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::difference_type arg2 ;
+  std::vector<ViewShape * >::value_type arg3 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer___setitem__" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer___setitem__" "', argument " "2"" of type '" "std::vector<ViewShape * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewShapesContainer___setitem__" "', argument " "3"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewShape_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::value_type arg2 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_append" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShapesContainer_append" "', argument " "2"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_ViewShape_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShapesContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewShapesContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<ViewShape * > *)new std::vector<ViewShape * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShapesContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = 0 ;
+  std::vector<ViewShape * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewShapesContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<ViewShape*,std::allocator<ViewShape * > > *ptr = (std::vector<ViewShape*,std::allocator<ViewShape * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewShapesContainer" "', argument " "1"" of type '" "std::vector<ViewShape * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewShapesContainer" "', argument " "1"" of type '" "std::vector<ViewShape * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<ViewShape * > *)new std::vector<ViewShape * >((std::vector<ViewShape * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_empty" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<ViewShape * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_size" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_clear" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_swap" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShapesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewShape * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShapesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewShape * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewShape * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  SwigValueWrapper<std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_get_allocator" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<ViewShape * >::allocator_type(static_cast< const std::vector<ViewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_end" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_end" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShapesContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShapesContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * >::size_type arg1 ;
+  std::vector<ViewShape * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewShapesContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewShapesContainer" "', argument " "1"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewShape * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<ViewShape * > *)new std::vector<ViewShape * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_pop_back" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator arg2 ;
+  std::vector<ViewShape * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator arg2 ;
+  std::vector<ViewShape * >::iterator arg3 ;
+  std::vector<ViewShape * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewShape * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewShape * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_ViewShapesContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_ViewShapesContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<ViewShape * >::iterator)\n    erase(std::vector<ViewShape * >::iterator,std::vector<ViewShape * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShapesContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * >::size_type arg1 ;
+  std::vector<ViewShape * >::value_type arg2 = (std::vector<ViewShape * >::value_type) 0 ;
+  std::vector<ViewShape * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewShapesContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewShapesContainer" "', argument " "1"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewShape * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewShapesContainer" "', argument " "2"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<ViewShape * > *)new std::vector<ViewShape * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShapesContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewShapesContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ViewShapesContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewShapesContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewShapesContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewShapesContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.ViewShape)>()\n    std::vector<(p.ViewShape)>(std::vector<ViewShape * > const &)\n    std::vector<(p.ViewShape)>(std::vector<ViewShape * >::size_type)\n    std::vector<(p.ViewShape)>(std::vector<ViewShape * >::size_type,std::vector<ViewShape * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::value_type arg2 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_push_back" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShapesContainer_push_back" "', argument " "2"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_front" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewShape * >::value_type)((std::vector<ViewShape * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_back" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewShape * >::value_type)((std::vector<ViewShape * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type arg2 ;
+  std::vector<ViewShape * >::value_type arg3 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_assign" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer_assign" "', argument " "2"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewShapesContainer_assign" "', argument " "3"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type arg2 ;
+  std::vector<ViewShape * >::value_type arg3 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewShapesContainer_resize" "', argument " "3"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewShapesContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewShapesContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<ViewShape * >::size_type)\n    resize(std::vector<ViewShape * >::size_type,std::vector<ViewShape * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator arg2 ;
+  std::vector<ViewShape * >::value_type arg3 = (std::vector<ViewShape * >::value_type) 0 ;
+  std::vector<ViewShape * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewShapesContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewShapesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewShape * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::iterator arg2 ;
+  std::vector<ViewShape * >::size_type arg3 ;
+  std::vector<ViewShape * >::value_type arg4 = (std::vector<ViewShape * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewShapesContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewShapesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewShape * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewShapesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewShape * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewShapesContainer_insert" "', argument " "4"" of type '" "std::vector<ViewShape * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<ViewShape * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewShapesContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewShape*,std::allocator<ViewShape * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewShape * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_ViewShapesContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShapesContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<ViewShape * >::iterator,std::vector<ViewShape * >::value_type)\n    insert(std::vector<ViewShape * >::iterator,std::vector<ViewShape * >::size_type,std::vector<ViewShape * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShapesContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_reserve" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewShapesContainer_reserve" "', argument " "2"" of type '" "std::vector<ViewShape * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewShape * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShapesContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  std::vector<ViewShape * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShapesContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShapesContainer_capacity" "', argument " "1"" of type '" "std::vector<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewShape * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewShapesContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewShape * > *arg1 = (std::vector<ViewShape * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewShapesContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewShapesContainer" "', argument " "1"" of type '" "std::vector<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewShape * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewShapesContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_iterator" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_ViewEdge_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___nonzero__" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_ViewEdge_Sm__Sg____nonzero__((std::vector<ViewEdge * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___len__" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_ViewEdge_Sm__Sg____len__((std::vector<ViewEdge * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_pop" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<ViewEdge * >::value_type)std_vector_Sl_ViewEdge_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  std::vector<ViewEdge * >::difference_type arg3 ;
+  std::vector<ViewEdge *,std::allocator<ViewEdge * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___getslice__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___getslice__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewEdgesContainer___getslice__" "', argument " "3"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewEdge * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<ViewEdge *,std::allocator<ViewEdge * > > *)std_vector_Sl_ViewEdge_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  std::vector<ViewEdge * >::difference_type arg3 ;
+  std::vector<ViewEdge *,std::allocator<ViewEdge * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewEdgesContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___setslice__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___setslice__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewEdgesContainer___setslice__" "', argument " "3"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewEdge * >::difference_type >(val3);
+  {
+    std::vector<ViewEdge*,std::allocator<ViewEdge * > > *ptr = (std::vector<ViewEdge*,std::allocator<ViewEdge * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewEdgesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewEdge *,std::allocator<ViewEdge * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewEdge *,std::allocator<ViewEdge * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_ViewEdge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<ViewEdge *,std::allocator<ViewEdge * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  std::vector<ViewEdge * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___delslice__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___delslice__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewEdgesContainer___delslice__" "', argument " "3"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewEdge * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewEdge_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___delitem__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___delitem__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewEdge_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  std::vector<ViewEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___getitem__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___getitem__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<ViewEdge * >::value_type)std_vector_Sl_ViewEdge_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::difference_type arg2 ;
+  std::vector<ViewEdge * >::value_type arg3 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer___setitem__" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer___setitem__" "', argument " "2"" of type '" "std::vector<ViewEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgesContainer___setitem__" "', argument " "3"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewEdge_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::value_type arg2 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_append" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgesContainer_append" "', argument " "2"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_ViewEdge_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgesContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewEdgesContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<ViewEdge * > *)new std::vector<ViewEdge * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgesContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = 0 ;
+  std::vector<ViewEdge * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewEdgesContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<ViewEdge*,std::allocator<ViewEdge * > > *ptr = (std::vector<ViewEdge*,std::allocator<ViewEdge * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdgesContainer" "', argument " "1"" of type '" "std::vector<ViewEdge * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewEdgesContainer" "', argument " "1"" of type '" "std::vector<ViewEdge * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<ViewEdge * > *)new std::vector<ViewEdge * >((std::vector<ViewEdge * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_empty" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<ViewEdge * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_size" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_clear" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_swap" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewEdge * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  SwigValueWrapper<std::allocator<ViewEdge * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_get_allocator" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<ViewEdge * >::allocator_type(static_cast< const std::vector<ViewEdge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_end" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_end" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgesContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgesContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * >::size_type arg1 ;
+  std::vector<ViewEdge * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewEdgesContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewEdgesContainer" "', argument " "1"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewEdge * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<ViewEdge * > *)new std::vector<ViewEdge * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_pop_back" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator arg2 ;
+  std::vector<ViewEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator arg2 ;
+  std::vector<ViewEdge * >::iterator arg3 ;
+  std::vector<ViewEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewEdge * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_ViewEdgesContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_ViewEdgesContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<ViewEdge * >::iterator)\n    erase(std::vector<ViewEdge * >::iterator,std::vector<ViewEdge * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgesContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * >::size_type arg1 ;
+  std::vector<ViewEdge * >::value_type arg2 = (std::vector<ViewEdge * >::value_type) 0 ;
+  std::vector<ViewEdge * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewEdgesContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewEdgesContainer" "', argument " "1"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewEdge * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdgesContainer" "', argument " "2"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<ViewEdge * > *)new std::vector<ViewEdge * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgesContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewEdgesContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ViewEdgesContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewEdgesContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewEdgesContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewEdgesContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.ViewEdge)>()\n    std::vector<(p.ViewEdge)>(std::vector<ViewEdge * > const &)\n    std::vector<(p.ViewEdge)>(std::vector<ViewEdge * >::size_type)\n    std::vector<(p.ViewEdge)>(std::vector<ViewEdge * >::size_type,std::vector<ViewEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::value_type arg2 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_push_back" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgesContainer_push_back" "', argument " "2"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_front" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewEdge * >::value_type)((std::vector<ViewEdge * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_back" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewEdge * >::value_type)((std::vector<ViewEdge * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type arg2 ;
+  std::vector<ViewEdge * >::value_type arg3 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_assign" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer_assign" "', argument " "2"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgesContainer_assign" "', argument " "3"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type arg2 ;
+  std::vector<ViewEdge * >::value_type arg3 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgesContainer_resize" "', argument " "3"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewEdgesContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewEdgesContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<ViewEdge * >::size_type)\n    resize(std::vector<ViewEdge * >::size_type,std::vector<ViewEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator arg2 ;
+  std::vector<ViewEdge * >::value_type arg3 = (std::vector<ViewEdge * >::value_type) 0 ;
+  std::vector<ViewEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgesContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::iterator arg2 ;
+  std::vector<ViewEdge * >::size_type arg3 ;
+  std::vector<ViewEdge * >::value_type arg4 = (std::vector<ViewEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewEdgesContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewEdge * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewEdgesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewEdge * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewEdgesContainer_insert" "', argument " "4"" of type '" "std::vector<ViewEdge * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<ViewEdge * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewEdgesContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewEdge*,std::allocator<ViewEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_ViewEdgesContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgesContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<ViewEdge * >::iterator,std::vector<ViewEdge * >::value_type)\n    insert(std::vector<ViewEdge * >::iterator,std::vector<ViewEdge * >::size_type,std::vector<ViewEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgesContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_reserve" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgesContainer_reserve" "', argument " "2"" of type '" "std::vector<ViewEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewEdge * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgesContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  std::vector<ViewEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgesContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgesContainer_capacity" "', argument " "1"" of type '" "std::vector<ViewEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewEdge * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewEdgesContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewEdge * > *arg1 = (std::vector<ViewEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewEdgesContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewEdgesContainer" "', argument " "1"" of type '" "std::vector<ViewEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewEdge * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewEdgesContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_iterator" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_FEdge_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___nonzero__" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_FEdge_Sm__Sg____nonzero__((std::vector<FEdge * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___len__" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_FEdge_Sm__Sg____len__((std::vector<FEdge * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_pop" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<FEdge * >::value_type)std_vector_Sl_FEdge_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  std::vector<FEdge * >::difference_type arg3 ;
+  std::vector<FEdge *,std::allocator<FEdge * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___getslice__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___getslice__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FEdgesContainer___getslice__" "', argument " "3"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<FEdge * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<FEdge *,std::allocator<FEdge * > > *)std_vector_Sl_FEdge_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  std::vector<FEdge * >::difference_type arg3 ;
+  std::vector<FEdge *,std::allocator<FEdge * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:FEdgesContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___setslice__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___setslice__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FEdgesContainer___setslice__" "', argument " "3"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<FEdge * >::difference_type >(val3);
+  {
+    std::vector<FEdge*,std::allocator<FEdge * > > *ptr = (std::vector<FEdge*,std::allocator<FEdge * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FEdgesContainer___setslice__" "', argument " "4"" of type '" "std::vector<FEdge *,std::allocator<FEdge * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgesContainer___setslice__" "', argument " "4"" of type '" "std::vector<FEdge *,std::allocator<FEdge * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_FEdge_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<FEdge *,std::allocator<FEdge * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  std::vector<FEdge * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___delslice__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___delslice__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FEdgesContainer___delslice__" "', argument " "3"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<FEdge * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_FEdge_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___delitem__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___delitem__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_FEdge_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  std::vector<FEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___getitem__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___getitem__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<FEdge * >::value_type)std_vector_Sl_FEdge_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::difference_type arg2 ;
+  std::vector<FEdge * >::value_type arg3 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer___setitem__" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer___setitem__" "', argument " "2"" of type '" "std::vector<FEdge * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FEdgesContainer___setitem__" "', argument " "3"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_FEdge_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::value_type arg2 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_append" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgesContainer_append" "', argument " "2"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_FEdge_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgesContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FEdgesContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<FEdge * > *)new std::vector<FEdge * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgesContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdgesContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<FEdge*,std::allocator<FEdge * > > *ptr = (std::vector<FEdge*,std::allocator<FEdge * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FEdgesContainer" "', argument " "1"" of type '" "std::vector<FEdge * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FEdgesContainer" "', argument " "1"" of type '" "std::vector<FEdge * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<FEdge * > *)new std::vector<FEdge * >((std::vector<FEdge * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_empty" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<FEdge * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_size" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_clear" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_swap" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgesContainer_swap" "', argument " "2"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FEdgesContainer_swap" "', argument " "2"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  SwigValueWrapper<std::allocator<FEdge * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_get_allocator" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<FEdge * >::allocator_type(static_cast< const std::vector<FEdge * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_begin" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_begin" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_end" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_end" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_rbegin" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_rbegin" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_rend" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_rend" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FEdgesContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgesContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * >::size_type arg1 ;
+  std::vector<FEdge * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FEdgesContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FEdgesContainer" "', argument " "1"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<FEdge * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<FEdge * > *)new std::vector<FEdge * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_pop_back" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_resize" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer_resize" "', argument " "2"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator arg2 ;
+  std::vector<FEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_erase" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator arg2 ;
+  std::vector<FEdge * >::iterator arg3 ;
+  std::vector<FEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_erase" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "3"" of type '" "std::vector<FEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_erase" "', argument " "3"" of type '" "std::vector<FEdge * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_FEdgesContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_FEdgesContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<FEdge * >::iterator)\n    erase(std::vector<FEdge * >::iterator,std::vector<FEdge * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgesContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * >::size_type arg1 ;
+  std::vector<FEdge * >::value_type arg2 = (std::vector<FEdge * >::value_type) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FEdgesContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FEdgesContainer" "', argument " "1"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<FEdge * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FEdgesContainer" "', argument " "2"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<FEdge * > *)new std::vector<FEdge * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FEdgesContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_FEdgesContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FEdgesContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FEdgesContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FEdgesContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_FEdgesContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.FEdge)>()\n    std::vector<(p.FEdge)>(std::vector<FEdge * > const &)\n    std::vector<(p.FEdge)>(std::vector<FEdge * >::size_type)\n    std::vector<(p.FEdge)>(std::vector<FEdge * >::size_type,std::vector<FEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::value_type arg2 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_push_back" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FEdgesContainer_push_back" "', argument " "2"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_front" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (std::vector<FEdge * >::value_type)((std::vector<FEdge * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_back" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = (std::vector<FEdge * >::value_type)((std::vector<FEdge * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type arg2 ;
+  std::vector<FEdge * >::value_type arg3 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_assign" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer_assign" "', argument " "2"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FEdgesContainer_assign" "', argument " "3"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type arg2 ;
+  std::vector<FEdge * >::value_type arg3 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_resize" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer_resize" "', argument " "2"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FEdgesContainer_resize" "', argument " "3"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FEdgesContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FEdgesContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<FEdge * >::size_type)\n    resize(std::vector<FEdge * >::size_type,std::vector<FEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator arg2 ;
+  std::vector<FEdge * >::value_type arg3 = (std::vector<FEdge * >::value_type) 0 ;
+  std::vector<FEdge * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FEdgesContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_insert" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FEdgesContainer_insert" "', argument " "3"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<FEdge * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::iterator arg2 ;
+  std::vector<FEdge * >::size_type arg3 ;
+  std::vector<FEdge * >::value_type arg4 = (std::vector<FEdge * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:FEdgesContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_insert" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FEdgesContainer_insert" "', argument " "2"" of type '" "std::vector<FEdge * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FEdgesContainer_insert" "', argument " "3"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<FEdge * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FEdgesContainer_insert" "', argument " "4"" of type '" "std::vector<FEdge * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<FEdge * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FEdgesContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<FEdge*,std::allocator<FEdge * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<FEdge * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_FEdgesContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FEdgesContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<FEdge * >::iterator,std::vector<FEdge * >::value_type)\n    insert(std::vector<FEdge * >::iterator,std::vector<FEdge * >::size_type,std::vector<FEdge * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FEdgesContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_reserve" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FEdgesContainer_reserve" "', argument " "2"" of type '" "std::vector<FEdge * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<FEdge * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FEdgesContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  std::vector<FEdge * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FEdgesContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FEdgesContainer_capacity" "', argument " "1"" of type '" "std::vector<FEdge * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<FEdge * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FEdgesContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<FEdge * > *arg1 = (std::vector<FEdge * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FEdgesContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FEdgesContainer" "', argument " "1"" of type '" "std::vector<FEdge * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<FEdge * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FEdgesContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_iterator" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_ViewVertex_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___nonzero__" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_ViewVertex_Sm__Sg____nonzero__((std::vector<ViewVertex * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___len__" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_ViewVertex_Sm__Sg____len__((std::vector<ViewVertex * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_pop" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<ViewVertex * >::value_type)std_vector_Sl_ViewVertex_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  std::vector<ViewVertex * >::difference_type arg3 ;
+  std::vector<ViewVertex *,std::allocator<ViewVertex * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___getslice__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___getslice__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewVerticesContainer___getslice__" "', argument " "3"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewVertex * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<ViewVertex *,std::allocator<ViewVertex * > > *)std_vector_Sl_ViewVertex_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  std::vector<ViewVertex * >::difference_type arg3 ;
+  std::vector<ViewVertex *,std::allocator<ViewVertex * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewVerticesContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___setslice__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___setslice__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewVerticesContainer___setslice__" "', argument " "3"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewVertex * >::difference_type >(val3);
+  {
+    std::vector<ViewVertex*,std::allocator<ViewVertex * > > *ptr = (std::vector<ViewVertex*,std::allocator<ViewVertex * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewVerticesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewVertex *,std::allocator<ViewVertex * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewVerticesContainer___setslice__" "', argument " "4"" of type '" "std::vector<ViewVertex *,std::allocator<ViewVertex * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_ViewVertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<ViewVertex *,std::allocator<ViewVertex * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  std::vector<ViewVertex * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___delslice__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___delslice__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewVerticesContainer___delslice__" "', argument " "3"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewVertex * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewVertex_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___delitem__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___delitem__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewVertex_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  std::vector<ViewVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___getitem__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___getitem__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<ViewVertex * >::value_type)std_vector_Sl_ViewVertex_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::difference_type arg2 ;
+  std::vector<ViewVertex * >::value_type arg3 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer___setitem__" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer___setitem__" "', argument " "2"" of type '" "std::vector<ViewVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewVerticesContainer___setitem__" "', argument " "3"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_ViewVertex_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::value_type arg2 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_append" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVerticesContainer_append" "', argument " "2"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_ViewVertex_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVerticesContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewVerticesContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<ViewVertex * > *)new std::vector<ViewVertex * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVerticesContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = 0 ;
+  std::vector<ViewVertex * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewVerticesContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<ViewVertex*,std::allocator<ViewVertex * > > *ptr = (std::vector<ViewVertex*,std::allocator<ViewVertex * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewVerticesContainer" "', argument " "1"" of type '" "std::vector<ViewVertex * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVerticesContainer" "', argument " "1"" of type '" "std::vector<ViewVertex * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<ViewVertex * > *)new std::vector<ViewVertex * >((std::vector<ViewVertex * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_empty" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<ViewVertex * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_size" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_clear" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_swap" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVerticesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewVertex * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewVerticesContainer_swap" "', argument " "2"" of type '" "std::vector<ViewVertex * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewVertex * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  SwigValueWrapper<std::allocator<ViewVertex * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_get_allocator" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<ViewVertex * >::allocator_type(static_cast< const std::vector<ViewVertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_begin" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_end" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_end" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_rbegin" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_rend" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVerticesContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVerticesContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * >::size_type arg1 ;
+  std::vector<ViewVertex * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewVerticesContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewVerticesContainer" "', argument " "1"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewVertex * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<ViewVertex * > *)new std::vector<ViewVertex * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_pop_back" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator arg2 ;
+  std::vector<ViewVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator arg2 ;
+  std::vector<ViewVertex * >::iterator arg3 ;
+  std::vector<ViewVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_erase" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_erase" "', argument " "3"" of type '" "std::vector<ViewVertex * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_ViewVerticesContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_ViewVerticesContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<ViewVertex * >::iterator)\n    erase(std::vector<ViewVertex * >::iterator,std::vector<ViewVertex * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVerticesContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * >::size_type arg1 ;
+  std::vector<ViewVertex * >::value_type arg2 = (std::vector<ViewVertex * >::value_type) 0 ;
+  std::vector<ViewVertex * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewVerticesContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewVerticesContainer" "', argument " "1"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<ViewVertex * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewVerticesContainer" "', argument " "2"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<ViewVertex * > *)new std::vector<ViewVertex * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVerticesContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewVerticesContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ViewVerticesContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewVerticesContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewVerticesContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewVerticesContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.ViewVertex)>()\n    std::vector<(p.ViewVertex)>(std::vector<ViewVertex * > const &)\n    std::vector<(p.ViewVertex)>(std::vector<ViewVertex * >::size_type)\n    std::vector<(p.ViewVertex)>(std::vector<ViewVertex * >::size_type,std::vector<ViewVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::value_type arg2 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_push_back" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVerticesContainer_push_back" "', argument " "2"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_front" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewVertex * >::value_type)((std::vector<ViewVertex * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_back" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = (std::vector<ViewVertex * >::value_type)((std::vector<ViewVertex * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type arg2 ;
+  std::vector<ViewVertex * >::value_type arg3 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_assign" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer_assign" "', argument " "2"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewVerticesContainer_assign" "', argument " "3"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type arg2 ;
+  std::vector<ViewVertex * >::value_type arg3 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_resize" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer_resize" "', argument " "2"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewVerticesContainer_resize" "', argument " "3"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewVerticesContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewVerticesContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<ViewVertex * >::size_type)\n    resize(std::vector<ViewVertex * >::size_type,std::vector<ViewVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator arg2 ;
+  std::vector<ViewVertex * >::value_type arg3 = (std::vector<ViewVertex * >::value_type) 0 ;
+  std::vector<ViewVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVerticesContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewVerticesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<ViewVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::iterator arg2 ;
+  std::vector<ViewVertex * >::size_type arg3 ;
+  std::vector<ViewVertex * >::value_type arg4 = (std::vector<ViewVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ViewVerticesContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_insert" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ViewVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<ViewVertex * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewVerticesContainer_insert" "', argument " "3"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<ViewVertex * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewVerticesContainer_insert" "', argument " "4"" of type '" "std::vector<ViewVertex * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<ViewVertex * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ViewVerticesContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<ViewVertex*,std::allocator<ViewVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<ViewVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_ViewVerticesContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVerticesContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<ViewVertex * >::iterator,std::vector<ViewVertex * >::value_type)\n    insert(std::vector<ViewVertex * >::iterator,std::vector<ViewVertex * >::size_type,std::vector<ViewVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVerticesContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_reserve" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVerticesContainer_reserve" "', argument " "2"" of type '" "std::vector<ViewVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<ViewVertex * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVerticesContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  std::vector<ViewVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVerticesContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVerticesContainer_capacity" "', argument " "1"" of type '" "std::vector<ViewVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<ViewVertex * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewVerticesContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<ViewVertex * > *arg1 = (std::vector<ViewVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewVerticesContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewVerticesContainer" "', argument " "1"" of type '" "std::vector<ViewVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<ViewVertex * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewVerticesContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_iterator" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_SVertex_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___nonzero__" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_SVertex_Sm__Sg____nonzero__((std::vector<SVertex * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___len__" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_SVertex_Sm__Sg____len__((std::vector<SVertex * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_pop" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<SVertex * >::value_type)std_vector_Sl_SVertex_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  std::vector<SVertex * >::difference_type arg3 ;
+  std::vector<SVertex *,std::allocator<SVertex * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___getslice__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___getslice__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SVerticesContainer___getslice__" "', argument " "3"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<SVertex * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<SVertex *,std::allocator<SVertex * > > *)std_vector_Sl_SVertex_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  std::vector<SVertex * >::difference_type arg3 ;
+  std::vector<SVertex *,std::allocator<SVertex * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SVerticesContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___setslice__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___setslice__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SVerticesContainer___setslice__" "', argument " "3"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<SVertex * >::difference_type >(val3);
+  {
+    std::vector<SVertex*,std::allocator<SVertex * > > *ptr = (std::vector<SVertex*,std::allocator<SVertex * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SVerticesContainer___setslice__" "', argument " "4"" of type '" "std::vector<SVertex *,std::allocator<SVertex * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVerticesContainer___setslice__" "', argument " "4"" of type '" "std::vector<SVertex *,std::allocator<SVertex * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_SVertex_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<SVertex *,std::allocator<SVertex * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  std::vector<SVertex * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___delslice__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___delslice__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SVerticesContainer___delslice__" "', argument " "3"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<SVertex * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_SVertex_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___delitem__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___delitem__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_SVertex_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  std::vector<SVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___getitem__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___getitem__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<SVertex * >::value_type)std_vector_Sl_SVertex_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::difference_type arg2 ;
+  std::vector<SVertex * >::value_type arg3 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer___setitem__" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer___setitem__" "', argument " "2"" of type '" "std::vector<SVertex * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVerticesContainer___setitem__" "', argument " "3"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_SVertex_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::value_type arg2 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_append" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVerticesContainer_append" "', argument " "2"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_SVertex_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVerticesContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_SVerticesContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<SVertex * > *)new std::vector<SVertex * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVerticesContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = 0 ;
+  std::vector<SVertex * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_SVerticesContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<SVertex*,std::allocator<SVertex * > > *ptr = (std::vector<SVertex*,std::allocator<SVertex * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SVerticesContainer" "', argument " "1"" of type '" "std::vector<SVertex * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SVerticesContainer" "', argument " "1"" of type '" "std::vector<SVertex * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<SVertex * > *)new std::vector<SVertex * >((std::vector<SVertex * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_empty" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<SVertex * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_size" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_clear" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_swap" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVerticesContainer_swap" "', argument " "2"" of type '" "std::vector<SVertex * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SVerticesContainer_swap" "', argument " "2"" of type '" "std::vector<SVertex * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<SVertex * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  SwigValueWrapper<std::allocator<SVertex * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_get_allocator" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<SVertex * >::allocator_type(static_cast< const std::vector<SVertex * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_begin" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_begin" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_end" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_end" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_rbegin" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_rbegin" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_rend" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_rend" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_SVerticesContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVerticesContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * >::size_type arg1 ;
+  std::vector<SVertex * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_SVerticesContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SVerticesContainer" "', argument " "1"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<SVertex * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<SVertex * > *)new std::vector<SVertex * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_pop_back" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_resize" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer_resize" "', argument " "2"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator arg2 ;
+  std::vector<SVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_erase" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator arg2 ;
+  std::vector<SVertex * >::iterator arg3 ;
+  std::vector<SVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_erase" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "3"" of type '" "std::vector<SVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_erase" "', argument " "3"" of type '" "std::vector<SVertex * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_SVerticesContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_SVerticesContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<SVertex * >::iterator)\n    erase(std::vector<SVertex * >::iterator,std::vector<SVertex * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVerticesContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * >::size_type arg1 ;
+  std::vector<SVertex * >::value_type arg2 = (std::vector<SVertex * >::value_type) 0 ;
+  std::vector<SVertex * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_SVerticesContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SVerticesContainer" "', argument " "1"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<SVertex * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SVerticesContainer" "', argument " "2"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<SVertex * > *)new std::vector<SVertex * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SVerticesContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_SVerticesContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_SVerticesContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_SVerticesContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_SVerticesContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_SVerticesContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.SVertex)>()\n    std::vector<(p.SVertex)>(std::vector<SVertex * > const &)\n    std::vector<(p.SVertex)>(std::vector<SVertex * >::size_type)\n    std::vector<(p.SVertex)>(std::vector<SVertex * >::size_type,std::vector<SVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::value_type arg2 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_push_back" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SVerticesContainer_push_back" "', argument " "2"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_front" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (std::vector<SVertex * >::value_type)((std::vector<SVertex * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_back" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = (std::vector<SVertex * >::value_type)((std::vector<SVertex * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type arg2 ;
+  std::vector<SVertex * >::value_type arg3 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_assign" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer_assign" "', argument " "2"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVerticesContainer_assign" "', argument " "3"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type arg2 ;
+  std::vector<SVertex * >::value_type arg3 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_resize" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer_resize" "', argument " "2"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVerticesContainer_resize" "', argument " "3"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_SVerticesContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_SVerticesContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<SVertex * >::size_type)\n    resize(std::vector<SVertex * >::size_type,std::vector<SVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator arg2 ;
+  std::vector<SVertex * >::value_type arg3 = (std::vector<SVertex * >::value_type) 0 ;
+  std::vector<SVertex * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SVerticesContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_insert" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SVerticesContainer_insert" "', argument " "3"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<SVertex * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::iterator arg2 ;
+  std::vector<SVertex * >::size_type arg3 ;
+  std::vector<SVertex * >::value_type arg4 = (std::vector<SVertex * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:SVerticesContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_insert" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SVerticesContainer_insert" "', argument " "2"" of type '" "std::vector<SVertex * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SVerticesContainer_insert" "', argument " "3"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<SVertex * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SVerticesContainer_insert" "', argument " "4"" of type '" "std::vector<SVertex * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<SVertex * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_SVerticesContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<SVertex*,std::allocator<SVertex * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<SVertex * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_SVerticesContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SVerticesContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<SVertex * >::iterator,std::vector<SVertex * >::value_type)\n    insert(std::vector<SVertex * >::iterator,std::vector<SVertex * >::size_type,std::vector<SVertex * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SVerticesContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_reserve" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SVerticesContainer_reserve" "', argument " "2"" of type '" "std::vector<SVertex * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<SVertex * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SVerticesContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  std::vector<SVertex * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SVerticesContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SVerticesContainer_capacity" "', argument " "1"" of type '" "std::vector<SVertex * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<SVertex * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SVerticesContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<SVertex * > *arg1 = (std::vector<SVertex * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SVerticesContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SVerticesContainer" "', argument " "1"" of type '" "std::vector<SVertex * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<SVertex * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SVerticesContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewMap_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_userdata_set" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_userdata_get" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewMap")) SWIG_fail;
+  {
+    try {
+      result = (ViewMap *)new ViewMap();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewMap, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewMap",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewMap" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_GetClosestViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewMap_GetClosestViewEdge",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_GetClosestViewEdge" "', argument " "1"" of type '" "ViewMap const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewMap_GetClosestViewEdge" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewMap_GetClosestViewEdge" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      result = (ViewEdge *)((ViewMap const *)arg1)->GetClosestViewEdge(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_GetClosestFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewMap_GetClosestFEdge",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_GetClosestFEdge" "', argument " "1"" of type '" "ViewMap const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewMap_GetClosestFEdge" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ViewMap_GetClosestFEdge" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      result = (FEdge *)((ViewMap const *)arg1)->GetClosestFEdge(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":ViewMap_getInstance")) SWIG_fail;
+  {
+    try {
+      result = (ViewMap *)ViewMap::getInstance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewMap, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_ViewShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::viewshapes_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_ViewShapes",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_ViewShapes" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::viewshapes_container &_result_ref = (arg1)->ViewShapes();
+        result = (ViewMap::viewshapes_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_ViewEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::viewedges_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_ViewEdges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_ViewEdges" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::viewedges_container &_result_ref = (arg1)->ViewEdges();
+        result = (ViewMap::viewedges_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_ViewVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::viewvertices_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_ViewVertices",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_ViewVertices" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::viewvertices_container &_result_ref = (arg1)->ViewVertices();
+        result = (ViewMap::viewvertices_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_FEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::fedges_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_FEdges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_FEdges" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::fedges_container &_result_ref = (arg1)->FEdges();
+        result = (ViewMap::fedges_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_SVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::svertices_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_SVertices",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_SVertices" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::svertices_container &_result_ref = (arg1)->SVertices();
+        result = (ViewMap::svertices_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_viewedges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::viewedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_viewedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_viewedges_begin" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      result = (arg1)->viewedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const ViewMap::viewedges_container::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_viewedges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::viewedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_viewedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_viewedges_end" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      result = (arg1)->viewedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const ViewMap::viewedges_container::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_viewedges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_viewedges_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_viewedges_size" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      result = (int)(arg1)->viewedges_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_viewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  unsigned int arg2 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_viewShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_viewShape" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewMap_viewShape" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      result = (ViewShape *)(arg1)->viewShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_shapeIdToIndexMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewMap::id_to_index_map *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_shapeIdToIndexMap",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_shapeIdToIndexMap" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      {
+        ViewMap::id_to_index_map &_result_ref = (arg1)->shapeIdToIndexMap();
+        result = (ViewMap::id_to_index_map *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_getScene3dBBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  SwigValueWrapper<BBox<VecMat::Vec3<double > > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMap_getScene3dBBox",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_getScene3dBBox" "', argument " "1"" of type '" "ViewMap const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  {
+    try {
+      result = ((ViewMap const *)arg1)->getScene3dBBox();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new BBox<Geometry::Vec3r >(static_cast< const BBox<Geometry::Vec3r >& >(result))), SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_AddViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_AddViewShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_AddViewShape" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_AddViewShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (arg1)->AddViewShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_AddViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_AddViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_AddViewEdge" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_AddViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_AddViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_AddViewVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_AddViewVertex" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_AddViewVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->AddViewVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_AddFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_AddFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_AddFEdge" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_AddFEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddFEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_AddSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_AddSVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_AddSVertex" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_AddSVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->AddSVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_setScene3dBBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  BBox<Geometry::Vec3r > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewMap_setScene3dBBox",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_setScene3dBBox" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_setScene3dBBox" "', argument " "2"" of type '" "BBox<Geometry::Vec3r > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_setScene3dBBox" "', argument " "2"" of type '" "BBox<Geometry::Vec3r > const &""'"); 
+  }
+  arg2 = reinterpret_cast< BBox<Geometry::Vec3r > * >(argp2);
+  {
+    try {
+      (arg1)->setScene3dBBox((BBox<Geometry::Vec3r > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_CreateTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  Geometry::Vec3r *arg3 = 0 ;
+  FEdge *arg4 = (FEdge *) 0 ;
+  Geometry::Vec3r *arg5 = 0 ;
+  Geometry::Vec3r *arg6 = 0 ;
+  FEdge *arg7 = (FEdge *) 0 ;
+  Id *arg8 = 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  void *argp7 = 0 ;
+  int res7 = 0 ;
+  void *argp8 = 0 ;
+  int res8 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  PyObject * obj7 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ViewMap_CreateTVertex",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_CreateTVertex" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_CreateTVertex" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_CreateTVertex" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewMap_CreateTVertex" "', argument " "3"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_CreateTVertex" "', argument " "3"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec3r * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewMap_CreateTVertex" "', argument " "4"" of type '" "FEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< FEdge * >(argp4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ViewMap_CreateTVertex" "', argument " "5"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp5) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_CreateTVertex" "', argument " "5"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg5 = reinterpret_cast< Geometry::Vec3r * >(argp5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ViewMap_CreateTVertex" "', argument " "6"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_CreateTVertex" "', argument " "6"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg6 = reinterpret_cast< Geometry::Vec3r * >(argp6);
+  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res7)) {
+    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ViewMap_CreateTVertex" "', argument " "7"" of type '" "FEdge *""'"); 
+  }
+  arg7 = reinterpret_cast< FEdge * >(argp7);
+  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res8)) {
+    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ViewMap_CreateTVertex" "', argument " "8"" of type '" "Id const &""'"); 
+  }
+  if (!argp8) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_CreateTVertex" "', argument " "8"" of type '" "Id const &""'"); 
+  }
+  arg8 = reinterpret_cast< Id * >(argp8);
+  {
+    try {
+      result = (TVertex *)(arg1)->CreateTVertex((Geometry::Vec3r const &)*arg2,(Geometry::Vec3r const &)*arg3,arg4,(Geometry::Vec3r const &)*arg5,(Geometry::Vec3r const &)*arg6,arg7,(Id const &)*arg8);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMap_InsertViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewMap *arg1 = (ViewMap *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  std::vector<ViewEdge * > *arg3 = 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewMap_InsertViewVertex",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMap_InsertViewVertex" "', argument " "1"" of type '" "ViewMap *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewMap * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMap_InsertViewVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewMap_InsertViewVertex" "', argument " "3"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMap_InsertViewVertex" "', argument " "3"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<ViewEdge * > * >(argp3);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->InsertViewVertex(arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewMap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewMap, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewVertex_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_getExactTypeName" "', argument " "1"" of type '" "ViewVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = ((ViewVertex const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertex_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_userdata_set" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertex_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_userdata_get" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewVertex" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_getNature" "', argument " "1"" of type '" "ViewVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)((ViewVertex const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_setNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  Nature::VertexNature arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned short val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertex_setNature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_setNature" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewVertex_setNature" "', argument " "2"" of type '" "Nature::VertexNature""'");
+  } 
+  arg2 = static_cast< Nature::VertexNature >(val2);
+  {
+    try {
+      (arg1)->setNature(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewEdge *arg3 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewVertex_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_Replace" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertex_Replace" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewVertex_Replace" "', argument " "3"" of type '" "ViewEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< ViewEdge * >(argp3);
+  {
+    try {
+      (arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_begin" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::edge_iterator(static_cast< const ViewVertex::edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_begin" "', argument " "1"" of type '" "ViewVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = ((ViewVertex const *)arg1)->edges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::const_edge_iterator(static_cast< const ViewVertex::const_edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVertex_edges_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVertex_edges_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVertex_edges_begin'.\n  Possible C/C++ prototypes are:\n    edges_begin()\n    edges_begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_end" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::edge_iterator(static_cast< const ViewVertex::edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_end" "', argument " "1"" of type '" "ViewVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = ((ViewVertex const *)arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::const_edge_iterator(static_cast< const ViewVertex::const_edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVertex_edges_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewVertex_edges_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVertex_edges_end'.\n  Possible C/C++ prototypes are:\n    edges_end()\n    edges_end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_iterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertex_edges_iterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_iterator" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertex_edges_iterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = (arg1)->edges_iterator(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::edge_iterator(static_cast< const ViewVertex::edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_iterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertex_edges_iterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edges_iterator" "', argument " "1"" of type '" "ViewVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertex_edges_iterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = ((ViewVertex const *)arg1)->edges_iterator(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::const_edge_iterator(static_cast< const ViewVertex::const_edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edges_iterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_ViewVertex_edges_iterator__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_ViewVertex_edges_iterator__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewVertex_edges_iterator'.\n  Possible C/C++ prototypes are:\n    edges_iterator(ViewEdge *)\n    edges_iterator(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edgesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edgesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edgesBegin" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edgesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertex_edgesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edgesEnd" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertex_edgesIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertex_edgesIterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertex_edgesIterator" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertex_edgesIterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = (arg1)->edgesIterator(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewVertex, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_TVertex_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getExactTypeName" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = ((TVertex const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getX" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getY" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getZ" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getPoint3D" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = ((TVertex const *)arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getProjectedX" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getProjectedY" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getProjectedZ" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (real)((TVertex const *)arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getPoint2D" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = ((TVertex const *)arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_getId" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = ((TVertex const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_castToViewVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_castToTVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (TVertex *)(arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_TVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_TVertex")) SWIG_fail;
+  {
+    try {
+      result = (TVertex *)new TVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_TVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_TVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      result = (TVertex *)new TVertex(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_TVertex(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_TVertex__SWIG_0(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_TVertex__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_TVertex'.\n  Possible C/C++ prototypes are:\n    TVertex()\n    TVertex(SVertex *,SVertex *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_frontSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_frontSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_frontSVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->frontSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_backSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_backSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_backSVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->backSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_frontEdgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_frontEdgeA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_frontEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      {
+        ViewVertex::directedViewEdge &_result_ref = (arg1)->frontEdgeA();
+        result = (ViewVertex::directedViewEdge *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_frontEdgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_frontEdgeB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_frontEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      {
+        ViewVertex::directedViewEdge &_result_ref = (arg1)->frontEdgeB();
+        result = (ViewVertex::directedViewEdge *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_backEdgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_backEdgeA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_backEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      {
+        ViewVertex::directedViewEdge &_result_ref = (arg1)->backEdgeA();
+        result = (ViewVertex::directedViewEdge *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_backEdgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_backEdgeB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_backEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      {
+        ViewVertex::directedViewEdge &_result_ref = (arg1)->backEdgeB();
+        result = (ViewVertex::directedViewEdge *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setFrontVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setFrontVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setFrontVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setFrontVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setBackSVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setBackSVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setBackSVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setBackSVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TVertex_setFrontEdgeA",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setFrontEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setFrontEdgeA" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TVertex_setFrontEdgeA" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setFrontEdgeA(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setFrontEdgeA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setFrontEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setFrontEdgeA" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setFrontEdgeA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeA(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_TVertex_setFrontEdgeA__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_TVertex_setFrontEdgeA__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TVertex_setFrontEdgeA'.\n  Possible C/C++ prototypes are:\n    setFrontEdgeA(ViewEdge *,bool)\n    setFrontEdgeA(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TVertex_setFrontEdgeB",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setFrontEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setFrontEdgeB" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TVertex_setFrontEdgeB" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setFrontEdgeB(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setFrontEdgeB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setFrontEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setFrontEdgeB" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setFrontEdgeB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setFrontEdgeB(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_TVertex_setFrontEdgeB__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_TVertex_setFrontEdgeB__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TVertex_setFrontEdgeB'.\n  Possible C/C++ prototypes are:\n    setFrontEdgeB(ViewEdge *,bool)\n    setFrontEdgeB(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TVertex_setBackEdgeA",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setBackEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setBackEdgeA" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TVertex_setBackEdgeA" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setBackEdgeA(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setBackEdgeA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setBackEdgeA" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setBackEdgeA" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setBackEdgeA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeA(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_TVertex_setBackEdgeA__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_TVertex_setBackEdgeA__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TVertex_setBackEdgeA'.\n  Possible C/C++ prototypes are:\n    setBackEdgeA(ViewEdge *,bool)\n    setBackEdgeA(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TVertex_setBackEdgeB",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setBackEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setBackEdgeB" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TVertex_setBackEdgeB" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setBackEdgeB(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setBackEdgeB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setBackEdgeB" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setBackEdgeB" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setBackEdgeB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setBackEdgeB(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_TVertex_setBackEdgeB__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_TVertex_setBackEdgeB__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TVertex_setBackEdgeB'.\n  Possible C/C++ prototypes are:\n    setBackEdgeB(ViewEdge *,bool)\n    setBackEdgeB(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_setId" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TVertex_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_GetSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_GetSVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_GetSVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_GetSVertex" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      result = (SVertex *)(arg1)->GetSVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewEdge *arg3 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TVertex_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_Replace" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_Replace" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TVertex_Replace" "', argument " "3"" of type '" "ViewEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< ViewEdge * >(argp3);
+  {
+    try {
+      (arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_mate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_mate",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_mate" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_mate" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = (ViewEdge *)(arg1)->mate(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_edges_end" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::edge_iterator(static_cast< const ViewVertex::edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_edges_end" "', argument " "1"" of type '" "TVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = ((TVertex const *)arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::const_edge_iterator(static_cast< const ViewVertex::const_edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edges_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_TVertex_edges_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_TVertex_edges_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'TVertex_edges_end'.\n  Possible C/C++ prototypes are:\n    edges_end()\n    edges_end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edgesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_edgesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_edgesBegin" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edgesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TVertex_edgesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_edgesEnd" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TVertex_edgesIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TVertex_edgesIterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TVertex_edgesIterator" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TVertex_edgesIterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = (arg1)->edgesIterator(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  TVertex *arg1 = (TVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_TVertex, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TVertex" "', argument " "1"" of type '" "TVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< TVertex * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_TVertex, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getExactTypeName" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = ((NonTVertex const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getX" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getY" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getZ" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getPoint3D" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = ((NonTVertex const *)arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getProjectedX" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getProjectedY" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getProjectedZ" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (real)((NonTVertex const *)arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getPoint2D" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = ((NonTVertex const *)arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_getId" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = ((NonTVertex const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_castToSVertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_castToViewVertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_castToNonTVertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_NonTVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_NonTVertex")) SWIG_fail;
+  {
+    try {
+      result = (NonTVertex *)new NonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_NonTVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_NonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonTVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)new NonTVertex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_NonTVertex(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_NonTVertex__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_NonTVertex__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_NonTVertex'.\n  Possible C/C++ prototypes are:\n    NonTVertex()\n    NonTVertex(SVertex *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_NonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_NonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonTVertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_svertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_svertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_svertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->svertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_viewedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  NonTVertex::edges_container *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_viewedges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_viewedges" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      {
+        NonTVertex::edges_container &_result_ref = (arg1)->viewedges();
+        result = (NonTVertex::edges_container *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_setSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_setSVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_setSVertex" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_setSVertex" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setSVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_setViewEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  std::vector<ViewVertex::directedViewEdge > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_setViewEdges",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_setViewEdges" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_setViewEdges" "', argument " "2"" of type '" "std::vector<ViewVertex::directedViewEdge > const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonTVertex_setViewEdges" "', argument " "2"" of type '" "std::vector<ViewVertex::directedViewEdge > const &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<ViewVertex::directedViewEdge > * >(argp2);
+  {
+    try {
+      (arg1)->setViewEdges((std::vector<ViewVertex::directedViewEdge > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_AddIncomingViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_AddIncomingViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_AddIncomingViewEdge" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_AddIncomingViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddIncomingViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_AddOutgoingViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_AddOutgoingViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_AddOutgoingViewEdge" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_AddOutgoingViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddOutgoingViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_AddViewEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:NonTVertex_AddViewEdge",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_AddViewEdge" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_AddViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NonTVertex_AddViewEdge" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->AddViewEdge(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_AddViewEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_AddViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_AddViewEdge" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_AddViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_AddViewEdge(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NonTVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_NonTVertex_AddViewEdge__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NonTVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_NonTVertex_AddViewEdge__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'NonTVertex_AddViewEdge'.\n  Possible C/C++ prototypes are:\n    AddViewEdge(ViewEdge *,bool)\n    AddViewEdge(ViewEdge *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewEdge *arg3 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:NonTVertex_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_Replace" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_Replace" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonTVertex_Replace" "', argument " "3"" of type '" "ViewEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< ViewEdge * >(argp3);
+  {
+    try {
+      (arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_edges_end" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::edge_iterator(static_cast< const ViewVertex::edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  SwigValueWrapper<ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_edges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_edges_end" "', argument " "1"" of type '" "NonTVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = ((NonTVertex const *)arg1)->edges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertex::const_edge_iterator(static_cast< const ViewVertex::const_edge_iterator& >(result))), SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edges_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NonTVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_NonTVertex_edges_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_NonTVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_NonTVertex_edges_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'NonTVertex_edges_end'.\n  Possible C/C++ prototypes are:\n    edges_end()\n    edges_end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edgesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_edgesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_edgesBegin" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edgesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:NonTVertex_edgesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_edgesEnd" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->edgesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_NonTVertex_edgesIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  NonTVertex *arg1 = (NonTVertex *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:NonTVertex_edgesIterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NonTVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonTVertex_edgesIterator" "', argument " "1"" of type '" "NonTVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< NonTVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonTVertex_edgesIterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      result = (arg1)->edgesIterator(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new ViewVertexInternal::orientedViewEdgeIterator(static_cast< const ViewVertexInternal::orientedViewEdgeIterator& >(result))), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *NonTVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_NonTVertex, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewEdge_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_getExactTypeName" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = ((ViewEdge const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_getId" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = ((ViewEdge const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_getNature" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (Nature::EdgeNature)((ViewEdge const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_userdata_set" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_userdata_get" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewEdge")) SWIG_fail;
+  {
+    try {
+      result = (ViewEdge *)new ViewEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdge" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdge" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      result = (ViewEdge *)new ViewEdge(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdge__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ViewEdge",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdge" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdge" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ViewEdge" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  {
+    try {
+      result = (ViewEdge *)new ViewEdge(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdge__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  FEdge *arg4 = (FEdge *) 0 ;
+  ViewShape *arg5 = (ViewShape *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ViewEdge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdge" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdge" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ViewEdge" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ViewEdge" "', argument " "4"" of type '" "FEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< FEdge * >(argp4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_ViewEdge" "', argument " "5"" of type '" "ViewShape *""'"); 
+  }
+  arg5 = reinterpret_cast< ViewShape * >(argp5);
+  {
+    try {
+      result = (ViewEdge *)new ViewEdge(arg1,arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdge(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewEdge__SWIG_0(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewEdge__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FEdge, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_ViewEdge__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FEdge, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_ViewShape, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_new_ViewEdge__SWIG_3(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewEdge'.\n  Possible C/C++ prototypes are:\n    ViewEdge()\n    ViewEdge(ViewVertex *,ViewVertex *)\n    ViewEdge(ViewVertex *,ViewVertex *,FEdge *)\n    ViewEdge(ViewVertex *,ViewVertex *,FEdge *,FEdge *,ViewShape *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewEdge" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_A" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_B" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_fedgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_fedgeA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_fedgeA" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->fedgeA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_fedgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_fedgeB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_fedgeB" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->fedgeB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_viewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_viewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_viewShape" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(arg1)->viewShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_aShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_aShape" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_isClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_isClosed",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_isClosed" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->isClosed();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_getChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_getChainingTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_getChainingTimeStamp" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (unsigned int)(arg1)->getChainingTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_aShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_aShape" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewShape *)((ViewEdge const *)arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_aShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdge_aShape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdge_aShape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdge_aShape'.\n  Possible C/C++ prototypes are:\n    aShape()\n    aShape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_bShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_bShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_bShape" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (ViewShape *)((ViewEdge const *)arg1)->bShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  std::vector<ViewShape * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluders",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluders" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      {
+        std::vector<ViewShape * > &_result_ref = (arg1)->occluders();
+        result = (std::vector<ViewShape * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_splittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Id *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_splittingId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_splittingId" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (Id *)(arg1)->splittingId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setA" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setA" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setB" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setB" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Nature::EdgeNature arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned short val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setNature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setNature" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdge_setNature" "', argument " "2"" of type '" "Nature::EdgeNature""'");
+  } 
+  arg2 = static_cast< Nature::EdgeNature >(val2);
+  {
+    try {
+      (arg1)->setNature(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setFEdgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setFEdgeA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setFEdgeA" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setFEdgeA" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->setFEdgeA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setFEdgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setFEdgeB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setFEdgeB" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setFEdgeB" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->setFEdgeB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setShape" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setId" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdge_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_UpdateFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_UpdateFEdges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_UpdateFEdges" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      (arg1)->UpdateFEdges();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setaShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setaShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setaShape" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setaShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (arg1)->setaShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setQI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setQI",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setQI" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdge_setQI" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      (arg1)->setQI(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setChainingTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setChainingTimeStamp" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdge_setChainingTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setChainingTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_AddOccluder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_AddOccluder",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_AddOccluder" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_AddOccluder" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (arg1)->AddOccluder(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_setSplittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Id *arg2 = (Id *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_setSplittingId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_setSplittingId" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_setSplittingId" "', argument " "2"" of type '" "Id *""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setSplittingId(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_intersect_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdge_intersect_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_intersect_2d_area" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdge_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdge_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdge_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)((ViewEdge const *)arg1)->intersect_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_include_in_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdge_include_in_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_include_in_2d_area" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdge_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdge_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdge_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdge_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)((ViewEdge const *)arg1)->include_in_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_getLength2D" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (real)((ViewEdge const *)arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_qi" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (int)((ViewEdge const *)arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluders_begin" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = ((ViewEdge const *)arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluders_end" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = ((ViewEdge const *)arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluders_size" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (int)((ViewEdge const *)arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluders_empty" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (bool)((ViewEdge const *)arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occludee" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = ((ViewEdge const *)arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occluded_shape" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (SShape *)((ViewEdge const *)arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_occludee_empty" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (bool)((ViewEdge const *)arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_shape_id" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = ((ViewEdge const *)arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_shape" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (SShape *)((ViewEdge const *)arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_shape_importance" "', argument " "1"" of type '" "ViewEdge const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (float)((ViewEdge const *)arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_verticesBegin" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_verticesEnd" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_pointsBegin" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdge_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_pointsBegin" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdge_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewEdge_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdge_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdge_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_pointsEnd" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdge_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdge *arg1 = (ViewEdge *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdge_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdge_pointsEnd" "', argument " "1"" of type '" "ViewEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdge * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdge_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdge_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdge, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewEdge_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdge_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewEdge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewEdge, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ViewShape_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_userdata_set" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_userdata_get" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  result = (void *) ((arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewShape")) SWIG_fail;
+  {
+    try {
+      result = (ViewShape *)new ViewShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SShape *arg1 = (SShape *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewShape" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (ViewShape *)new ViewShape(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShape__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewShape,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewShape" "', argument " "1"" of type '" "ViewShape &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewShape" "', argument " "1"" of type '" "ViewShape &""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = (ViewShape *)new ViewShape(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewShape__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SShape, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewShape__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewShape, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewShape__SWIG_2(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewShape'.\n  Possible C/C++ prototypes are:\n    ViewShape()\n    ViewShape(SShape *)\n    ViewShape(ViewShape &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_duplicate" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewShape" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_SplitEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  std::vector<TVertex * > *arg3 = 0 ;
+  std::vector<FEdge * > *arg4 = 0 ;
+  std::vector<ViewEdge * > *arg5 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ViewShape_SplitEdge",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_SplitEdge" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_SplitEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewShape_SplitEdge" "', argument " "3"" of type '" "std::vector<TVertex * > const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShape_SplitEdge" "', argument " "3"" of type '" "std::vector<TVertex * > const &""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<TVertex * > * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ViewShape_SplitEdge" "', argument " "4"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShape_SplitEdge" "', argument " "4"" of type '" "std::vector<FEdge * > &""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<FEdge * > * >(argp4);
+  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t,  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ViewShape_SplitEdge" "', argument " "5"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  if (!argp5) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShape_SplitEdge" "', argument " "5"" of type '" "std::vector<ViewEdge * > &""'"); 
+  }
+  arg5 = reinterpret_cast< std::vector<ViewEdge * > * >(argp5);
+  {
+    try {
+      (arg1)->SplitEdge(arg2,(std::vector<TVertex * > const &)*arg3,*arg4,*arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_sshape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_sshape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_sshape" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = (SShape *)(arg1)->sshape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_sshape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_sshape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_sshape" "', argument " "1"" of type '" "ViewShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = (SShape *)((ViewShape const *)arg1)->sshape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_sshape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewShape, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShape_sshape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewShape, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewShape_sshape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewShape_sshape'.\n  Possible C/C++ prototypes are:\n    sshape()\n    sshape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_vertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  std::vector<ViewVertex * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_vertices",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_vertices" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<ViewVertex * > &_result_ref = (arg1)->vertices();
+        result = (std::vector<ViewVertex * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_edges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  std::vector<ViewEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_edges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_edges" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      {
+        std::vector<ViewEdge * > &_result_ref = (arg1)->edges();
+        result = (std::vector<ViewEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewShape_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_getId" "', argument " "1"" of type '" "ViewShape const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = ((ViewShape const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_setSShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  SShape *arg2 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_setSShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_setSShape" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_setSShape" "', argument " "2"" of type '" "SShape *""'"); 
+  }
+  arg2 = reinterpret_cast< SShape * >(argp2);
+  {
+    try {
+      (arg1)->setSShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_setVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  std::vector<ViewVertex * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_setVertices",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_setVertices" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    std::vector<ViewVertex*,std::allocator<ViewVertex * > > *ptr = (std::vector<ViewVertex*,std::allocator<ViewVertex * > > *)0;
+    res2 = swig::asptr(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_setVertices" "', argument " "2"" of type '" "std::vector<ViewVertex * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShape_setVertices" "', argument " "2"" of type '" "std::vector<ViewVertex * > const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    try {
+      (arg1)->setVertices((std::vector<ViewVertex * > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_setEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  std::vector<ViewEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_setEdges",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_setEdges" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    std::vector<ViewEdge*,std::allocator<ViewEdge * > > *ptr = (std::vector<ViewEdge*,std::allocator<ViewEdge * > > *)0;
+    res2 = swig::asptr(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_setEdges" "', argument " "2"" of type '" "std::vector<ViewEdge * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewShape_setEdges" "', argument " "2"" of type '" "std::vector<ViewEdge * > const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    try {
+      (arg1)->setEdges((std::vector<ViewEdge * > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_AddVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_AddVertex" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_AddVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->AddVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_AddEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_AddEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_AddEdge" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_AddEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_RemoveEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_RemoveEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_RemoveEdge" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_RemoveEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->RemoveEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewShape_RemoveVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewShape *arg1 = (ViewShape *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewShape_RemoveVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewShape_RemoveVertex" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewShape_RemoveVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (arg1)->RemoveVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewShape, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewVertexOrientedViewEdgeIterator")) SWIG_fail;
+  {
+    try {
+      result = (ViewVertexInternal::orientedViewEdgeIterator *)new ViewVertexInternal::orientedViewEdgeIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Nature::VertexNature arg1 ;
+  ViewVertexInternal::orientedViewEdgeIterator *result = 0 ;
+  unsigned short val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewVertexOrientedViewEdgeIterator",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "Nature::VertexNature""'");
+  } 
+  arg1 = static_cast< Nature::VertexNature >(val1);
+  {
+    try {
+      result = (ViewVertexInternal::orientedViewEdgeIterator *)new ViewVertexInternal::orientedViewEdgeIterator(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewVertexOrientedViewEdgeIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertexInternal::orientedViewEdgeIterator *)new ViewVertexInternal::orientedViewEdgeIterator((ViewVertexInternal::orientedViewEdgeIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewVertexOrientedViewEdgeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewVertexOrientedViewEdgeIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator arg1 ;
+  ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator arg2 ;
+  ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator arg3 ;
+  ViewVertexInternal::orientedViewEdgeIterator *result = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ViewVertexOrientedViewEdgeIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * >(argp1);
+      arg1 = *temp;
+      if (SWIG_IsNewObj(res1)) delete temp;
+    }
+  }
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "3"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "3"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      result = (ViewVertexInternal::orientedViewEdgeIterator *)new ViewVertexInternal::orientedViewEdgeIterator(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator arg1 ;
+  ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator arg2 ;
+  ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator arg3 ;
+  ViewVertexInternal::orientedViewEdgeIterator *result = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ViewVertexOrientedViewEdgeIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'"); 
+    }  
+    if (!argp1) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * >(argp1);
+      arg1 = *temp;
+      if (SWIG_IsNewObj(res1)) delete temp;
+    }
+  }
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "3"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewVertexOrientedViewEdgeIterator" "', argument " "3"" of type '" "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator""'");
+    } else {
+      ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * temp = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      result = (ViewVertexInternal::orientedViewEdgeIterator *)new ViewVertexInternal::orientedViewEdgeIterator(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewVertexOrientedViewEdgeIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_1(self, args);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_3(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_ViewVertexOrientedViewEdgeIterator__SWIG_4(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewVertexOrientedViewEdgeIterator'.\n  Possible C/C++ prototypes are:\n    ViewVertexInternal::orientedViewEdgeIterator()\n    ViewVertexInternal::orientedViewEdgeIterator(Nature::VertexNature)\n    ViewVertexInternal::orientedViewEdgeIterator(ViewVertexInternal::orientedViewEdgeIterator const &)\n    ViewVertexInternal::orientedViewEdgeIterator(ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator,ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator,ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator)\n    ViewVertexInternal::orientedViewEdgeIterator(ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator,ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator,ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertexOrientedViewEdgeIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator_isBegin" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertexOrientedViewEdgeIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator_isEnd" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertexOrientedViewEdgeIterator___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator___ne__" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertexOrientedViewEdgeIterator___ne__" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewVertexOrientedViewEdgeIterator___ne__" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp2);
+  {
+    try {
+      result = (bool)((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->operator !=((ViewVertexInternal::orientedViewEdgeIterator const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  ViewVertexInternal::orientedViewEdgeIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewVertexOrientedViewEdgeIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator___eq__" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewVertexOrientedViewEdgeIterator___eq__" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewVertexOrientedViewEdgeIterator___eq__" "', argument " "2"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp2);
+  {
+    try {
+      result = (bool)((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->operator ==((ViewVertexInternal::orientedViewEdgeIterator const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  ::ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertexOrientedViewEdgeIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator_getObject" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      {
+        ::ViewVertex::directedViewEdge &_result_ref = ((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->operator *();
+        result = (::ViewVertex::directedViewEdge *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  ::ViewVertex::directedViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertexOrientedViewEdgeIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator___deref__" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (::ViewVertex::directedViewEdge *)((ViewVertexInternal::orientedViewEdgeIterator const *)arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairTViewEdge_p_bool_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewVertexOrientedViewEdgeIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertexInternal::orientedViewEdgeIterator *arg1 = (ViewVertexInternal::orientedViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewVertexOrientedViewEdgeIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewVertexOrientedViewEdgeIterator_increment" "', argument " "1"" of type '" "ViewVertexInternal::orientedViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertexInternal::orientedViewEdgeIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewVertexOrientedViewEdgeIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeSVertexIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ViewEdgeSVertexIterator")) SWIG_fail;
+  {
+    try {
+      result = (ViewEdgeInternal::SVertexIterator *)new ViewEdgeInternal::SVertexIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeSVertexIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = 0 ;
+  ViewEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewEdgeSVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewEdgeInternal__SVertexIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewEdgeSVertexIterator" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdgeInternal::SVertexIterator *)new ViewEdgeInternal::SVertexIterator((ViewEdgeInternal::SVertexIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeSVertexIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  FEdge *arg4 = (FEdge *) 0 ;
+  float arg5 ;
+  ViewEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ViewEdgeSVertexIterator",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "4"" of type '" "FEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< FEdge * >(argp4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ViewEdgeSVertexIterator" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      result = (ViewEdgeInternal::SVertexIterator *)new ViewEdgeInternal::SVertexIterator(arg1,arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeSVertexIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ViewEdgeSVertexIterator__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ViewEdgeSVertexIterator__SWIG_1(self, args);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FEdge, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_ViewEdgeSVertexIterator__SWIG_2(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewEdgeSVertexIterator'.\n  Possible C/C++ prototypes are:\n    ViewEdgeInternal::SVertexIterator()\n    ViewEdgeInternal::SVertexIterator(ViewEdgeInternal::SVertexIterator const &)\n    ViewEdgeInternal::SVertexIterator(SVertex *,SVertex *,FEdge *,FEdge *,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewEdgeSVertexIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewEdgeSVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewEdgeSVertexIterator" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getExactTypeName" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = ((ViewEdgeInternal::SVertexIterator const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getObject" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        SVertex &_result_ref = (arg1)->operator *();
+        result = (SVertex *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator___deref__" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_increment" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_decrement" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->decrement();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_isBegin" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ViewEdgeInternal::SVertexIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_isEnd" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ViewEdgeInternal::SVertexIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_t",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_t" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((ViewEdgeInternal::SVertexIterator const *)arg1)->t();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_u" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((ViewEdgeInternal::SVertexIterator const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator___eq__" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((ViewEdgeInternal::SVertexIterator const *)arg1)->operator ==((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  ViewEdgeInternal::SVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_copy" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdgeInternal::SVertexIterator *)((ViewEdgeInternal::SVertexIterator const *)arg1)->copy();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getX" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getY" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getZ" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getPoint3D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getProjectedX" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getProjectedY" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getProjectedZ" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getPoint2D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getFEdge" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getId" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getNature" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_castToSVertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_castToViewVertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_castToNonTVertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_castToTVertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_userdata_set" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (*arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_userdata_get" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  result = (void *) ((*arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_duplicate",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_duplicate" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->duplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_point3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_point3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_point3D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_point2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_point2D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2D();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_normals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SwigValueWrapper<set<VecMat::Vec3<double > > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_normals",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_normals" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normals();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new set<Geometry::Vec3r >(static_cast< const set<Geometry::Vec3r >& >(result))), SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_normalsSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_normalsSize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_normalsSize" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->normalsSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_fedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  std::vector<FEdge * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_fedges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_fedges" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        std::vector<FEdge * > const &_result_ref = (*arg1)->fedges();
+        result = (std::vector<FEdge * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<FEdge*,std::allocator<FEdge * > > >(*result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_fedges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_fedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_fedges_begin" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->fedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_fedges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SVertex::fedges_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_fedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_fedges_end" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->fedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new SVertex::fedges_container::iterator(static_cast< const SVertex::fedges_container::iterator& >(result))), SWIGTYPE_p_SVertex__fedges_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_shape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_shape" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_shape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_shape" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_shape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeSVertexIterator_shape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeSVertexIterator_shape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgeSVertexIterator_shape'.\n  Possible C/C++ prototypes are:\n    shape()\n    shape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_z",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_z" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_viewvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_viewvertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_viewvertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->viewvertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setPoint3D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setPoint3D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_setPoint3D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->setPoint3D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setPoint2D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setPoint2D" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_setPoint2D" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->setPoint2D((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_AddNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_AddNormal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_AddNormal" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_AddNormal" "', argument " "2"" of type '" "Geometry::Vec3r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3r * >(argp2);
+  {
+    try {
+      (*arg1)->AddNormal((Geometry::Vec3r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  CurvatureInfo *arg2 = (CurvatureInfo *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setCurvatureInfo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setCurvatureInfo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setCurvatureInfo" "', argument " "2"" of type '" "CurvatureInfo *""'"); 
+  }
+  arg2 = reinterpret_cast< CurvatureInfo * >(argp2);
+  {
+    try {
+      (*arg1)->setCurvatureInfo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_getCurvatureInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  CurvatureInfo *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_getCurvatureInfo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_getCurvatureInfo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (CurvatureInfo *)(*arg1)->getCurvatureInfo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvatureInfo, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setCurvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setCurvatureFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setCurvatureFredo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeSVertexIterator_setCurvatureFredo" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (*arg1)->setCurvatureFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setDirectionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2r arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setDirectionFredo",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setDirectionFredo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_setDirectionFredo" "', argument " "2"" of type '" "Geometry::Vec2r""'");
+    } else {
+      Geometry::Vec2r * temp = reinterpret_cast< Geometry::Vec2r * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  {
+    try {
+      (*arg1)->setDirectionFredo(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_curvatureFredo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec2r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_directionFredo" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2r(static_cast< const Geometry::Vec2r& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setId" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  std::vector<FEdge * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setFEdges",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setFEdges" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    std::vector<FEdge*,std::allocator<FEdge * > > *ptr = (std::vector<FEdge*,std::allocator<FEdge * > > *)0;
+    res2 = swig::asptr(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeSVertexIterator_setFEdges" "', argument " "2"" of type '" "std::vector<FEdge * > const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    try {
+      (*arg1)->setFEdges((std::vector<FEdge * > const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SShape *arg2 = (SShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setShape" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setShape" "', argument " "2"" of type '" "SShape *""'"); 
+  }
+  arg2 = reinterpret_cast< SShape * >(argp2);
+  {
+    try {
+      (*arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_setViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_setViewVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_setViewVertex" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_setViewVertex" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setViewVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_AddFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeSVertexIterator_AddFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_AddFEdge" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_AddFEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->AddFEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  FEdge *arg3 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgeSVertexIterator_Replace",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_Replace" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeSVertexIterator_Replace" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgeSVertexIterator_Replace" "', argument " "3"" of type '" "FEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< FEdge * >(argp3);
+  {
+    try {
+      (*arg1)->Replace(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_fedge" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_point2d" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_point3d" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_normal" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_shape_id" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_shape_importance" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_qi" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occluders_begin" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occluders_end" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occluders_empty" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occluders_size" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occludee" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occluded_shape" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_occludee_empty" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeSVertexIterator_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::SVertexIterator *arg1 = (ViewEdgeInternal::SVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeSVertexIterator_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeSVertexIterator_z_discontinuity" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewEdgeSVertexIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewEdgeInternal__SVertexIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeViewEdgeIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  bool arg3 ;
+  ViewEdgeInternal::ViewEdgeIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ViewEdgeViewEdgeIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdgeViewEdgeIterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ViewEdgeViewEdgeIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new SwigDirector_ViewEdgeViewEdgeIterator(arg1,arg2,arg3); 
+      } else {
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new ViewEdgeInternal::ViewEdgeIterator(arg2,arg3); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeViewEdgeIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewEdgeViewEdgeIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdgeViewEdgeIterator" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new SwigDirector_ViewEdgeViewEdgeIterator(arg1,arg2); 
+      } else {
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new ViewEdgeInternal::ViewEdgeIterator(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeViewEdgeIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewEdgeViewEdgeIterator",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new SwigDirector_ViewEdgeViewEdgeIterator(arg1); 
+      } else {
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new ViewEdgeInternal::ViewEdgeIterator(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeViewEdgeIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *arg2 = 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewEdgeViewEdgeIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ViewEdgeViewEdgeIterator" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ViewEdgeViewEdgeIterator" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new SwigDirector_ViewEdgeViewEdgeIterator(arg1,(ViewEdgeInternal::ViewEdgeIterator const &)*arg2); 
+      } else {
+        result = (ViewEdgeInternal::ViewEdgeIterator *)new ViewEdgeInternal::ViewEdgeIterator((ViewEdgeInternal::ViewEdgeIterator const &)*arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewEdgeViewEdgeIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_ViewEdgeViewEdgeIterator__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewEdgeViewEdgeIterator__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ViewEdgeViewEdgeIterator__SWIG_3(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ViewEdge, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ViewEdgeViewEdgeIterator__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewEdgeViewEdgeIterator'.\n  Possible C/C++ prototypes are:\n    ViewEdgeInternal::ViewEdgeIterator(PyObject *,ViewEdge *,bool)\n    ViewEdgeInternal::ViewEdgeIterator(PyObject *,ViewEdge *)\n    ViewEdgeInternal::ViewEdgeIterator(PyObject *)\n    ViewEdgeInternal::ViewEdgeIterator(PyObject *,ViewEdgeInternal::ViewEdgeIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewEdgeViewEdgeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewEdgeViewEdgeIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewEdgeViewEdgeIterator" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getExactTypeName" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->ViewEdgeInternal::ViewEdgeIterator::getExactTypeName();
+        } else {
+          result = ((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->getExactTypeName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getCurrentEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getCurrentEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getCurrentEdge" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)(arg1)->getCurrentEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setCurrentEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setCurrentEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setCurrentEdge" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setCurrentEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setCurrentEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)(arg1)->getBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setBegin" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->setBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getOrientation",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getOrientation" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->getOrientation();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setOrientation",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setOrientation" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_setOrientation" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->setOrientation(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_changeOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_changeOrientation",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_changeOrientation" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      (arg1)->changeOrientation();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getObject" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (ViewEdge *)(arg1)->ViewEdgeInternal::ViewEdgeIterator::operator *();
+        } else {
+          result = (ViewEdge *)(arg1)->operator *();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator___deref__" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (ViewEdge *)(arg1)->ViewEdgeInternal::ViewEdgeIterator::operator ->();
+        } else {
+          result = (ViewEdge *)(arg1)->operator ->();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_increment" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->ViewEdgeInternal::ViewEdgeIterator::increment();
+        } else {
+          (arg1)->increment();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_decrement" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->ViewEdgeInternal::ViewEdgeIterator::decrement();
+        } else {
+          (arg1)->decrement();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_isBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->ViewEdgeInternal::ViewEdgeIterator::isBegin();
+        } else {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->isBegin();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_isEnd" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->ViewEdgeInternal::ViewEdgeIterator::isEnd();
+        } else {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->isEnd();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator___eq__" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator___eq__" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator___eq__" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->ViewEdgeInternal::ViewEdgeIterator::operator ==(*arg2);
+        } else {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->operator ==(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewEdgeInternal::ViewEdgeIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator___ne__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator___ne__" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator___ne__" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator___ne__" "', argument " "2"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->ViewEdgeInternal::ViewEdgeIterator::operator !=(*arg2);
+        } else {
+          result = (bool)((ViewEdgeInternal::ViewEdgeIterator const *)arg1)->operator !=(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getId" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getNature" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (Nature::EdgeNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_userdata_set" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (*arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_userdata_get" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  result = (void *) ((*arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_A" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_B" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_fedgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_fedgeA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_fedgeA" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedgeA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_fedgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_fedgeB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_fedgeB" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedgeB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_viewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_viewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_viewShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->viewShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_aShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_aShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_aShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_aShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_aShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeViewEdgeIterator_aShape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeViewEdgeIterator_aShape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgeViewEdgeIterator_aShape'.\n  Possible C/C++ prototypes are:\n    aShape()\n    aShape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_isClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_isClosed",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_isClosed" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->isClosed();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getChainingTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getChainingTimeStamp" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->getChainingTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_bShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_bShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_bShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->bShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  std::vector<ViewShape * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluders",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluders" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      {
+        std::vector<ViewShape * > &_result_ref = (*arg1)->occluders();
+        result = (std::vector<ViewShape * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_splittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Id *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_splittingId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_splittingId" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (Id *)(*arg1)->splittingId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setA" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setA" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setB" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setB" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Nature::EdgeNature arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned short val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setNature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setNature" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_setNature" "', argument " "2"" of type '" "Nature::EdgeNature""'");
+  } 
+  arg2 = static_cast< Nature::EdgeNature >(val2);
+  {
+    try {
+      (*arg1)->setNature(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setFEdgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setFEdgeA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setFEdgeA" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setFEdgeA" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->setFEdgeA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setFEdgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setFEdgeB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setFEdgeB" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setFEdgeB" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->setFEdgeB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setId" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_UpdateFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_UpdateFEdges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_UpdateFEdges" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      (*arg1)->UpdateFEdges();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setaShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setaShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setaShape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setaShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->setaShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setQI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setQI",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setQI" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_setQI" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      (*arg1)->setQI(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setChainingTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setChainingTimeStamp" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_setChainingTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (*arg1)->setChainingTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_AddOccluder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_AddOccluder",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_AddOccluder" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_AddOccluder" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->AddOccluder(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setSplittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Id *arg2 = (Id *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setSplittingId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setSplittingId" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_setSplittingId" "', argument " "2"" of type '" "Id *""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setSplittingId(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_intersect_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgeViewEdgeIterator_intersect_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_intersect_2d_area" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgeViewEdgeIterator_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)(*arg1)->intersect_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_include_in_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewEdgeViewEdgeIterator_include_in_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_include_in_2d_area" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewEdgeViewEdgeIterator_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewEdgeViewEdgeIterator_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewEdgeViewEdgeIterator_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)(*arg1)->include_in_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getLength2D" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_qi" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluders_begin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluders_end" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluders_size" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluders_empty" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occludee" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occluded_shape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_occludee_empty" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_shape_id" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_shape" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_shape_importance" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_verticesBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_verticesEnd" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_pointsBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (*arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_pointsBegin" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeViewEdgeIterator_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewEdgeViewEdgeIterator_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgeViewEdgeIterator_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_pointsEnd" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (*arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_pointsEnd" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ViewEdgeViewEdgeIterator_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ViewEdgeViewEdgeIterator_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ViewEdgeViewEdgeIterator_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_getTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewEdgeViewEdgeIterator_getTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_getTimeStamp" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->getTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewEdgeViewEdgeIterator_setTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ViewEdgeViewEdgeIterator_setTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewEdgeViewEdgeIterator_setTimeStamp" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ViewEdgeViewEdgeIterator_setTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (*arg1)->setTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_ViewEdgeViewEdgeIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = (ViewEdgeInternal::ViewEdgeIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_ViewEdgeViewEdgeIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ViewEdgeViewEdgeIterator" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewEdgeViewEdgeIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<void > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DVoid",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<void > *)new SwigDirector_UnaryFunction0DVoid(arg1); 
+      } else {
+        result = (UnaryFunction0D<void > *)new UnaryFunction0D<void >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTvoid_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<void > *arg1 = (UnaryFunction0D<void > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DVoid",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTvoid_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DVoid" "', argument " "1"" of type '" "UnaryFunction0D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<void > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVoid_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<void > *arg1 = (UnaryFunction0D<void > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DVoid_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVoid_getName" "', argument " "1"" of type '" "UnaryFunction0D<void > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<void > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<void > const *)arg1)->UnaryFunction0D<void >::getName();
+        } else {
+          result = ((UnaryFunction0D<void > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVoid___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<void > *arg1 = (UnaryFunction0D<void > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DVoid___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVoid___call__" "', argument " "1"" of type '" "UnaryFunction0D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<void > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DVoid___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DVoid___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->UnaryFunction0D<void >::operator ()(*arg2);
+        } else {
+          (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<void > *arg1 = (UnaryFunction0D<void > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DVoid",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DVoid" "', argument " "1"" of type '" "UnaryFunction0D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<void > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DVoid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTvoid_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<unsigned int > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DUnsigned",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<unsigned int > *)new SwigDirector_UnaryFunction0DUnsigned(arg1); 
+      } else {
+        result = (UnaryFunction0D<unsigned int > *)new UnaryFunction0D<unsigned int >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = (UnaryFunction0D<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DUnsigned",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DUnsigned_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = (UnaryFunction0D<unsigned int > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DUnsigned_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DUnsigned_getName" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<unsigned int > const *)arg1)->UnaryFunction0D<unsigned int >::getName();
+        } else {
+          result = ((UnaryFunction0D<unsigned int > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DUnsigned___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = (UnaryFunction0D<unsigned int > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DUnsigned___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DUnsigned___call__" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DUnsigned___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DUnsigned___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (unsigned int)(arg1)->UnaryFunction0D<unsigned int >::operator ()(*arg2);
+        } else {
+          result = (unsigned int)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<unsigned int > *arg1 = (UnaryFunction0D<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DUnsigned",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DUnsigned" "', argument " "1"" of type '" "UnaryFunction0D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<unsigned int > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DUnsigned_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTunsigned_int_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<float > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DFloat",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<float > *)new SwigDirector_UnaryFunction0DFloat(arg1); 
+      } else {
+        result = (UnaryFunction0D<float > *)new UnaryFunction0D<float >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = (UnaryFunction0D<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DFloat",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTfloat_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DFloat_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = (UnaryFunction0D<float > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DFloat_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DFloat_getName" "', argument " "1"" of type '" "UnaryFunction0D<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<float > const *)arg1)->UnaryFunction0D<float >::getName();
+        } else {
+          result = ((UnaryFunction0D<float > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DFloat___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = (UnaryFunction0D<float > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DFloat___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DFloat___call__" "', argument " "1"" of type '" "UnaryFunction0D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DFloat___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DFloat___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (float)(arg1)->UnaryFunction0D<float >::operator ()(*arg2);
+        } else {
+          result = (float)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<float > *arg1 = (UnaryFunction0D<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DFloat",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DFloat" "', argument " "1"" of type '" "UnaryFunction0D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<float > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DFloat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTfloat_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<double > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DDouble",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<double > *)new SwigDirector_UnaryFunction0DDouble(arg1); 
+      } else {
+        result = (UnaryFunction0D<double > *)new UnaryFunction0D<double >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = (UnaryFunction0D<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DDouble",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTdouble_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DDouble_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = (UnaryFunction0D<double > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DDouble_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DDouble_getName" "', argument " "1"" of type '" "UnaryFunction0D<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<double > const *)arg1)->UnaryFunction0D<double >::getName();
+        } else {
+          result = ((UnaryFunction0D<double > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DDouble___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = (UnaryFunction0D<double > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DDouble___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DDouble___call__" "', argument " "1"" of type '" "UnaryFunction0D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DDouble___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DDouble___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (double)(arg1)->UnaryFunction0D<double >::operator ()(*arg2);
+        } else {
+          result = (double)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = (UnaryFunction0D<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DDouble",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DDouble" "', argument " "1"" of type '" "UnaryFunction0D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTdouble_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<Geometry::Vec2f > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DVec2f",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<Geometry::Vec2f > *)new SwigDirector_UnaryFunction0DVec2f(arg1); 
+      } else {
+        result = (UnaryFunction0D<Geometry::Vec2f > *)new UnaryFunction0D<Geometry::Vec2f >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec2f > *arg1 = (UnaryFunction0D<Geometry::Vec2f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DVec2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DVec2f" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec2f > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVec2f_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec2f > *arg1 = (UnaryFunction0D<Geometry::Vec2f > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DVec2f_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVec2f_getName" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec2f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec2f > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<Geometry::Vec2f > const *)arg1)->UnaryFunction0D<VecMat::Vec2<float > >::getName();
+        } else {
+          result = ((UnaryFunction0D<Geometry::Vec2f > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVec2f___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec2f > *arg1 = (UnaryFunction0D<Geometry::Vec2f > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DVec2f___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVec2f___call__" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec2f > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DVec2f___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DVec2f___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (arg1)->UnaryFunction0D<VecMat::Vec2<float > >::operator ()(*arg2);
+        } else {
+          result = (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec2f > *arg1 = (UnaryFunction0D<Geometry::Vec2f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DVec2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DVec2f" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec2f > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<Geometry::Vec3f > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DVec3f",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<Geometry::Vec3f > *)new SwigDirector_UnaryFunction0DVec3f(arg1); 
+      } else {
+        result = (UnaryFunction0D<Geometry::Vec3f > *)new UnaryFunction0D<Geometry::Vec3f >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec3f > *arg1 = (UnaryFunction0D<Geometry::Vec3f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DVec3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DVec3f" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec3f > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVec3f_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec3f > *arg1 = (UnaryFunction0D<Geometry::Vec3f > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DVec3f_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVec3f_getName" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec3f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec3f > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<Geometry::Vec3f > const *)arg1)->UnaryFunction0D<VecMat::Vec3<float > >::getName();
+        } else {
+          result = ((UnaryFunction0D<Geometry::Vec3f > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVec3f___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec3f > *arg1 = (UnaryFunction0D<Geometry::Vec3f > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DVec3f___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVec3f___call__" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec3f > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DVec3f___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DVec3f___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (arg1)->UnaryFunction0D<VecMat::Vec3<float > >::operator ()(*arg2);
+        } else {
+          result = (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Geometry::Vec3f > *arg1 = (UnaryFunction0D<Geometry::Vec3f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DVec3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DVec3f" "', argument " "1"" of type '" "UnaryFunction0D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Geometry::Vec3f > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction0D<Id > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction0DId",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction0D<Id > *)new SwigDirector_UnaryFunction0DId(arg1); 
+      } else {
+        result = (UnaryFunction0D<Id > *)new UnaryFunction0D<Id >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTId_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Id > *arg1 = (UnaryFunction0D<Id > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTId_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DId" "', argument " "1"" of type '" "UnaryFunction0D<Id > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Id > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DId_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Id > *arg1 = (UnaryFunction0D<Id > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DId_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTId_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DId_getName" "', argument " "1"" of type '" "UnaryFunction0D<Id > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Id > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction0D<Id > const *)arg1)->UnaryFunction0D<Id >::getName();
+        } else {
+          result = ((UnaryFunction0D<Id > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DId___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Id > *arg1 = (UnaryFunction0D<Id > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DId___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTId_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DId___call__" "', argument " "1"" of type '" "UnaryFunction0D<Id > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Id > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DId___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DId___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (arg1)->UnaryFunction0D<Id >::operator ()(*arg2);
+        } else {
+          result = (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction0DId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<Id > *arg1 = (UnaryFunction0D<Id > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction0DId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTId_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction0DId" "', argument " "1"" of type '" "UnaryFunction0D<Id > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<Id > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DId_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTId_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<ViewShape * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_UnaryFunction0DViewShape")) SWIG_fail;
+  {
+    try {
+      result = (UnaryFunction0D<ViewShape * > *)new UnaryFunction0D<ViewShape * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTViewShape_p_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<ViewShape * > *arg1 = (UnaryFunction0D<ViewShape * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTViewShape_p_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DViewShape" "', argument " "1"" of type '" "UnaryFunction0D<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<ViewShape * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DViewShape_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<ViewShape * > *arg1 = (UnaryFunction0D<ViewShape * > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DViewShape_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTViewShape_p_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DViewShape_getName" "', argument " "1"" of type '" "UnaryFunction0D<ViewShape * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<ViewShape * > * >(argp1);
+  {
+    try {
+      result = ((UnaryFunction0D<ViewShape * > const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DViewShape___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<ViewShape * > *arg1 = (UnaryFunction0D<ViewShape * > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DViewShape___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTViewShape_p_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DViewShape___call__" "', argument " "1"" of type '" "UnaryFunction0D<ViewShape * > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<ViewShape * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DViewShape___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DViewShape___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (ViewShape *)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DViewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTViewShape_p_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction0DVectorViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<std::vector<ViewShape * > > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_UnaryFunction0DVectorViewShape")) SWIG_fail;
+  {
+    try {
+      result = (UnaryFunction0D<std::vector<ViewShape * > > *)new UnaryFunction0D<std::vector<ViewShape * > >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction0DVectorViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<std::vector<ViewShape * > > *arg1 = (UnaryFunction0D<std::vector<ViewShape * > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction0DVectorViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction0DVectorViewShape" "', argument " "1"" of type '" "UnaryFunction0D<std::vector<ViewShape * > > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<std::vector<ViewShape * > > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVectorViewShape_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<std::vector<ViewShape * > > *arg1 = (UnaryFunction0D<std::vector<ViewShape * > > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction0DVectorViewShape_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVectorViewShape_getName" "', argument " "1"" of type '" "UnaryFunction0D<std::vector<ViewShape * > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<std::vector<ViewShape * > > * >(argp1);
+  {
+    try {
+      result = ((UnaryFunction0D<std::vector<ViewShape * > > const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction0DVectorViewShape___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<std::vector<ViewShape * > > *arg1 = (UnaryFunction0D<std::vector<ViewShape * > > *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction0DVectorViewShape___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction0DVectorViewShape___call__" "', argument " "1"" of type '" "UnaryFunction0D<std::vector<ViewShape * > > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<std::vector<ViewShape * > > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction0DVectorViewShape___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction0DVectorViewShape___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction0DVectorViewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetXF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetXF0D *arg1 = (Functions0D::GetXF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetXF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetXF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetXF0D_getName" "', argument " "1"" of type '" "Functions0D::GetXF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetXF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetXF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetXF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetXF0D *arg1 = (Functions0D::GetXF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetXF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetXF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetXF0D___call__" "', argument " "1"" of type '" "Functions0D::GetXF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetXF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetXF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetXF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetXF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetXF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetXF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetXF0D *)new Functions0D::GetXF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetXF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetXF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetXF0D *arg1 = (Functions0D::GetXF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetXF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetXF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetXF0D" "', argument " "1"" of type '" "Functions0D::GetXF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetXF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetXF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetXF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetYF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetYF0D *arg1 = (Functions0D::GetYF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetYF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetYF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetYF0D_getName" "', argument " "1"" of type '" "Functions0D::GetYF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetYF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetYF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetYF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetYF0D *arg1 = (Functions0D::GetYF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetYF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetYF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetYF0D___call__" "', argument " "1"" of type '" "Functions0D::GetYF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetYF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetYF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetYF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetYF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetYF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetYF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetYF0D *)new Functions0D::GetYF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetYF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetYF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetYF0D *arg1 = (Functions0D::GetYF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetYF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetYF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetYF0D" "', argument " "1"" of type '" "Functions0D::GetYF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetYF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetYF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetYF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetZF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetZF0D *arg1 = (Functions0D::GetZF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetZF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetZF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetZF0D_getName" "', argument " "1"" of type '" "Functions0D::GetZF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetZF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetZF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetZF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetZF0D *arg1 = (Functions0D::GetZF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetZF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetZF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetZF0D___call__" "', argument " "1"" of type '" "Functions0D::GetZF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetZF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetZF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetZF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetZF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetZF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetZF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetZF0D *)new Functions0D::GetZF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetZF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetZF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetZF0D *arg1 = (Functions0D::GetZF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetZF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetZF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetZF0D" "', argument " "1"" of type '" "Functions0D::GetZF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetZF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetZF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetZF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetProjectedXF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedXF0D *arg1 = (Functions0D::GetProjectedXF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedXF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedXF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedXF0D_getName" "', argument " "1"" of type '" "Functions0D::GetProjectedXF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedXF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetProjectedXF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedXF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedXF0D *arg1 = (Functions0D::GetProjectedXF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedXF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedXF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedXF0D___call__" "', argument " "1"" of type '" "Functions0D::GetProjectedXF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedXF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedXF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedXF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedXF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedXF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedXF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetProjectedXF0D *)new Functions0D::GetProjectedXF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetProjectedXF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedXF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedXF0D *arg1 = (Functions0D::GetProjectedXF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedXF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedXF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedXF0D" "', argument " "1"" of type '" "Functions0D::GetProjectedXF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedXF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedXF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetProjectedXF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetProjectedYF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedYF0D *arg1 = (Functions0D::GetProjectedYF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedYF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedYF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedYF0D_getName" "', argument " "1"" of type '" "Functions0D::GetProjectedYF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedYF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetProjectedYF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedYF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedYF0D *arg1 = (Functions0D::GetProjectedYF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedYF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedYF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedYF0D___call__" "', argument " "1"" of type '" "Functions0D::GetProjectedYF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedYF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedYF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedYF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedYF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedYF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedYF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetProjectedYF0D *)new Functions0D::GetProjectedYF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetProjectedYF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedYF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedYF0D *arg1 = (Functions0D::GetProjectedYF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedYF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedYF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedYF0D" "', argument " "1"" of type '" "Functions0D::GetProjectedYF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedYF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedYF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetProjectedYF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetProjectedZF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedZF0D *arg1 = (Functions0D::GetProjectedZF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedZF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedZF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedZF0D_getName" "', argument " "1"" of type '" "Functions0D::GetProjectedZF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedZF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetProjectedZF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedZF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedZF0D *arg1 = (Functions0D::GetProjectedZF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedZF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedZF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedZF0D___call__" "', argument " "1"" of type '" "Functions0D::GetProjectedZF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedZF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedZF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedZF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedZF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedZF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedZF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetProjectedZF0D *)new Functions0D::GetProjectedZF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetProjectedZF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedZF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetProjectedZF0D *arg1 = (Functions0D::GetProjectedZF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedZF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetProjectedZF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedZF0D" "', argument " "1"" of type '" "Functions0D::GetProjectedZF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetProjectedZF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedZF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetProjectedZF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetCurvilinearAbscissaF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetCurvilinearAbscissaF0D *arg1 = (Functions0D::GetCurvilinearAbscissaF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetCurvilinearAbscissaF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCurvilinearAbscissaF0D_getName" "', argument " "1"" of type '" "Functions0D::GetCurvilinearAbscissaF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetCurvilinearAbscissaF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetCurvilinearAbscissaF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetCurvilinearAbscissaF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetCurvilinearAbscissaF0D *arg1 = (Functions0D::GetCurvilinearAbscissaF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetCurvilinearAbscissaF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCurvilinearAbscissaF0D___call__" "', argument " "1"" of type '" "Functions0D::GetCurvilinearAbscissaF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetCurvilinearAbscissaF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetCurvilinearAbscissaF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetCurvilinearAbscissaF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetCurvilinearAbscissaF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetCurvilinearAbscissaF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetCurvilinearAbscissaF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetCurvilinearAbscissaF0D *)new Functions0D::GetCurvilinearAbscissaF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetCurvilinearAbscissaF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetCurvilinearAbscissaF0D *arg1 = (Functions0D::GetCurvilinearAbscissaF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetCurvilinearAbscissaF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetCurvilinearAbscissaF0D" "', argument " "1"" of type '" "Functions0D::GetCurvilinearAbscissaF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetCurvilinearAbscissaF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetCurvilinearAbscissaF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetCurvilinearAbscissaF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetParameterF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetParameterF0D *arg1 = (Functions0D::GetParameterF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetParameterF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetParameterF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetParameterF0D_getName" "', argument " "1"" of type '" "Functions0D::GetParameterF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetParameterF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetParameterF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetParameterF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetParameterF0D *arg1 = (Functions0D::GetParameterF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetParameterF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetParameterF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetParameterF0D___call__" "', argument " "1"" of type '" "Functions0D::GetParameterF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetParameterF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetParameterF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetParameterF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetParameterF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetParameterF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetParameterF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetParameterF0D *)new Functions0D::GetParameterF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetParameterF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetParameterF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetParameterF0D *arg1 = (Functions0D::GetParameterF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetParameterF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetParameterF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetParameterF0D" "', argument " "1"" of type '" "Functions0D::GetParameterF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetParameterF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetParameterF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetParameterF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_VertexOrientation2DF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation2DF0D *arg1 = (Functions0D::VertexOrientation2DF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:VertexOrientation2DF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation2DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexOrientation2DF0D_getName" "', argument " "1"" of type '" "Functions0D::VertexOrientation2DF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation2DF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::VertexOrientation2DF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VertexOrientation2DF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation2DF0D *arg1 = (Functions0D::VertexOrientation2DF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:VertexOrientation2DF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation2DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexOrientation2DF0D___call__" "', argument " "1"" of type '" "Functions0D::VertexOrientation2DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation2DF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VertexOrientation2DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VertexOrientation2DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_VertexOrientation2DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation2DF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_VertexOrientation2DF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::VertexOrientation2DF0D *)new Functions0D::VertexOrientation2DF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__VertexOrientation2DF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_VertexOrientation2DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation2DF0D *arg1 = (Functions0D::VertexOrientation2DF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_VertexOrientation2DF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation2DF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VertexOrientation2DF0D" "', argument " "1"" of type '" "Functions0D::VertexOrientation2DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation2DF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *VertexOrientation2DF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__VertexOrientation2DF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_VertexOrientation3DF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation3DF0D *arg1 = (Functions0D::VertexOrientation3DF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:VertexOrientation3DF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation3DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexOrientation3DF0D_getName" "', argument " "1"" of type '" "Functions0D::VertexOrientation3DF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation3DF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::VertexOrientation3DF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_VertexOrientation3DF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation3DF0D *arg1 = (Functions0D::VertexOrientation3DF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:VertexOrientation3DF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation3DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VertexOrientation3DF0D___call__" "', argument " "1"" of type '" "Functions0D::VertexOrientation3DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation3DF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VertexOrientation3DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VertexOrientation3DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_VertexOrientation3DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation3DF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_VertexOrientation3DF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::VertexOrientation3DF0D *)new Functions0D::VertexOrientation3DF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__VertexOrientation3DF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_VertexOrientation3DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::VertexOrientation3DF0D *arg1 = (Functions0D::VertexOrientation3DF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_VertexOrientation3DF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__VertexOrientation3DF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VertexOrientation3DF0D" "', argument " "1"" of type '" "Functions0D::VertexOrientation3DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::VertexOrientation3DF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *VertexOrientation3DF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__VertexOrientation3DF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Curvature2DAngleF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Curvature2DAngleF0D *arg1 = (Functions0D::Curvature2DAngleF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curvature2DAngleF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Curvature2DAngleF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curvature2DAngleF0D_getName" "', argument " "1"" of type '" "Functions0D::Curvature2DAngleF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Curvature2DAngleF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::Curvature2DAngleF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curvature2DAngleF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Curvature2DAngleF0D *arg1 = (Functions0D::Curvature2DAngleF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curvature2DAngleF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Curvature2DAngleF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curvature2DAngleF0D___call__" "', argument " "1"" of type '" "Functions0D::Curvature2DAngleF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Curvature2DAngleF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curvature2DAngleF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Curvature2DAngleF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curvature2DAngleF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Curvature2DAngleF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Curvature2DAngleF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::Curvature2DAngleF0D *)new Functions0D::Curvature2DAngleF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__Curvature2DAngleF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Curvature2DAngleF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Curvature2DAngleF0D *arg1 = (Functions0D::Curvature2DAngleF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Curvature2DAngleF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Curvature2DAngleF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Curvature2DAngleF0D" "', argument " "1"" of type '" "Functions0D::Curvature2DAngleF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Curvature2DAngleF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Curvature2DAngleF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__Curvature2DAngleF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ZDiscontinuityF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ZDiscontinuityF0D *arg1 = (Functions0D::ZDiscontinuityF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ZDiscontinuityF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ZDiscontinuityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZDiscontinuityF0D_getName" "', argument " "1"" of type '" "Functions0D::ZDiscontinuityF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ZDiscontinuityF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::ZDiscontinuityF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ZDiscontinuityF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ZDiscontinuityF0D *arg1 = (Functions0D::ZDiscontinuityF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ZDiscontinuityF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ZDiscontinuityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZDiscontinuityF0D___call__" "', argument " "1"" of type '" "Functions0D::ZDiscontinuityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ZDiscontinuityF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZDiscontinuityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZDiscontinuityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ZDiscontinuityF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ZDiscontinuityF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ZDiscontinuityF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::ZDiscontinuityF0D *)new Functions0D::ZDiscontinuityF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__ZDiscontinuityF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ZDiscontinuityF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ZDiscontinuityF0D *arg1 = (Functions0D::ZDiscontinuityF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ZDiscontinuityF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ZDiscontinuityF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZDiscontinuityF0D" "', argument " "1"" of type '" "Functions0D::ZDiscontinuityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ZDiscontinuityF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ZDiscontinuityF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__ZDiscontinuityF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Normal2DF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Normal2DF0D *arg1 = (Functions0D::Normal2DF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Normal2DF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Normal2DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Normal2DF0D_getName" "', argument " "1"" of type '" "Functions0D::Normal2DF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Normal2DF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::Normal2DF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Normal2DF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Normal2DF0D *arg1 = (Functions0D::Normal2DF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Normal2DF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Normal2DF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Normal2DF0D___call__" "', argument " "1"" of type '" "Functions0D::Normal2DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Normal2DF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Normal2DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Normal2DF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Normal2DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Normal2DF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Normal2DF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::Normal2DF0D *)new Functions0D::Normal2DF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__Normal2DF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Normal2DF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::Normal2DF0D *arg1 = (Functions0D::Normal2DF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Normal2DF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__Normal2DF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Normal2DF0D" "', argument " "1"" of type '" "Functions0D::Normal2DF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::Normal2DF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Normal2DF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__Normal2DF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_MaterialF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::MaterialF0D *arg1 = (Functions0D::MaterialF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:MaterialF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__MaterialF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MaterialF0D_getName" "', argument " "1"" of type '" "Functions0D::MaterialF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::MaterialF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::MaterialF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MaterialF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::MaterialF0D *arg1 = (Functions0D::MaterialF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Material result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:MaterialF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__MaterialF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MaterialF0D___call__" "', argument " "1"" of type '" "Functions0D::MaterialF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::MaterialF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MaterialF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MaterialF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Material(static_cast< const Material& >(result))), SWIGTYPE_p_Material, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_MaterialF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::MaterialF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_MaterialF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::MaterialF0D *)new Functions0D::MaterialF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__MaterialF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_MaterialF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::MaterialF0D *arg1 = (Functions0D::MaterialF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaterialF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__MaterialF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaterialF0D" "', argument " "1"" of type '" "Functions0D::MaterialF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::MaterialF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *MaterialF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__MaterialF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ShapeIdF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ShapeIdF0D *arg1 = (Functions0D::ShapeIdF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShapeIdF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ShapeIdF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShapeIdF0D_getName" "', argument " "1"" of type '" "Functions0D::ShapeIdF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ShapeIdF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::ShapeIdF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShapeIdF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ShapeIdF0D *arg1 = (Functions0D::ShapeIdF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShapeIdF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ShapeIdF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShapeIdF0D___call__" "', argument " "1"" of type '" "Functions0D::ShapeIdF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ShapeIdF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShapeIdF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShapeIdF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShapeIdF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ShapeIdF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ShapeIdF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::ShapeIdF0D *)new Functions0D::ShapeIdF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__ShapeIdF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ShapeIdF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ShapeIdF0D *arg1 = (Functions0D::ShapeIdF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ShapeIdF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ShapeIdF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShapeIdF0D" "', argument " "1"" of type '" "Functions0D::ShapeIdF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ShapeIdF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ShapeIdF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__ShapeIdF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::QuantitativeInvisibilityF0D *arg1 = (Functions0D::QuantitativeInvisibilityF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:QuantitativeInvisibilityF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityF0D_getName" "', argument " "1"" of type '" "Functions0D::QuantitativeInvisibilityF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::QuantitativeInvisibilityF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::QuantitativeInvisibilityF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::QuantitativeInvisibilityF0D *arg1 = (Functions0D::QuantitativeInvisibilityF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:QuantitativeInvisibilityF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityF0D___call__" "', argument " "1"" of type '" "Functions0D::QuantitativeInvisibilityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::QuantitativeInvisibilityF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuantitativeInvisibilityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuantitativeInvisibilityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (unsigned int)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::QuantitativeInvisibilityF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_QuantitativeInvisibilityF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::QuantitativeInvisibilityF0D *)new Functions0D::QuantitativeInvisibilityF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_QuantitativeInvisibilityF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::QuantitativeInvisibilityF0D *arg1 = (Functions0D::QuantitativeInvisibilityF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuantitativeInvisibilityF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantitativeInvisibilityF0D" "', argument " "1"" of type '" "Functions0D::QuantitativeInvisibilityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::QuantitativeInvisibilityF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *QuantitativeInvisibilityF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__QuantitativeInvisibilityF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_CurveNatureF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::CurveNatureF0D *arg1 = (Functions0D::CurveNatureF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurveNatureF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__CurveNatureF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveNatureF0D_getName" "', argument " "1"" of type '" "Functions0D::CurveNatureF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::CurveNatureF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::CurveNatureF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurveNatureF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::CurveNatureF0D *arg1 = (Functions0D::CurveNatureF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurveNatureF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__CurveNatureF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveNatureF0D___call__" "', argument " "1"" of type '" "Functions0D::CurveNatureF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::CurveNatureF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurveNatureF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurveNatureF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (Nature::EdgeNature)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurveNatureF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::CurveNatureF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_CurveNatureF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::CurveNatureF0D *)new Functions0D::CurveNatureF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__CurveNatureF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CurveNatureF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::CurveNatureF0D *arg1 = (Functions0D::CurveNatureF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CurveNatureF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__CurveNatureF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurveNatureF0D" "', argument " "1"" of type '" "Functions0D::CurveNatureF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::CurveNatureF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CurveNatureF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__CurveNatureF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetShapeF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetShapeF0D *arg1 = (Functions0D::GetShapeF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetShapeF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetShapeF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShapeF0D_getName" "', argument " "1"" of type '" "Functions0D::GetShapeF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetShapeF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetShapeF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetShapeF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetShapeF0D *arg1 = (Functions0D::GetShapeF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetShapeF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetShapeF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShapeF0D___call__" "', argument " "1"" of type '" "Functions0D::GetShapeF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetShapeF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetShapeF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShapeF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (ViewShape *)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetShapeF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetShapeF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetShapeF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetShapeF0D *)new Functions0D::GetShapeF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetShapeF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetShapeF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetShapeF0D *arg1 = (Functions0D::GetShapeF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetShapeF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetShapeF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetShapeF0D" "', argument " "1"" of type '" "Functions0D::GetShapeF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetShapeF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetShapeF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetShapeF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetOccludersF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludersF0D *arg1 = (Functions0D::GetOccludersF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetOccludersF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludersF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludersF0D_getName" "', argument " "1"" of type '" "Functions0D::GetOccludersF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludersF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetOccludersF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludersF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludersF0D *arg1 = (Functions0D::GetOccludersF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetOccludersF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludersF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludersF0D___call__" "', argument " "1"" of type '" "Functions0D::GetOccludersF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludersF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOccludersF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOccludersF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetOccludersF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludersF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetOccludersF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetOccludersF0D *)new Functions0D::GetOccludersF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetOccludersF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetOccludersF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludersF0D *arg1 = (Functions0D::GetOccludersF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetOccludersF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludersF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetOccludersF0D" "', argument " "1"" of type '" "Functions0D::GetOccludersF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludersF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetOccludersF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetOccludersF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetOccludeeF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludeeF0D *arg1 = (Functions0D::GetOccludeeF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetOccludeeF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludeeF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludeeF0D_getName" "', argument " "1"" of type '" "Functions0D::GetOccludeeF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludeeF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetOccludeeF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludeeF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludeeF0D *arg1 = (Functions0D::GetOccludeeF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetOccludeeF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludeeF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludeeF0D___call__" "', argument " "1"" of type '" "Functions0D::GetOccludeeF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludeeF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOccludeeF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOccludeeF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (ViewShape *)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetOccludeeF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludeeF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetOccludeeF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::GetOccludeeF0D *)new Functions0D::GetOccludeeF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetOccludeeF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetOccludeeF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetOccludeeF0D *arg1 = (Functions0D::GetOccludeeF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetOccludeeF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetOccludeeF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetOccludeeF0D" "', argument " "1"" of type '" "Functions0D::GetOccludeeF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetOccludeeF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetOccludeeF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetOccludeeF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getFEdge" "', argument " "1"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getFEdge" "', argument " "1"" of type '" "Interface0D &""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)Functions0D::getFEdge(*arg1,*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVoid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<void > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DVoid",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<void > *)new SwigDirector_UnaryFunction1DVoid(arg1); 
+      } else {
+        result = (UnaryFunction1D<void > *)new UnaryFunction1D<void >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTvoid_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVoid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<void > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DVoid",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DVoid" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<void > *)new SwigDirector_UnaryFunction1DVoid(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<void > *)new UnaryFunction1D<void >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTvoid_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVoid(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DVoid__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DVoid__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DVoid'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(void)>(PyObject *)\n    UnaryFunction1D<(void)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DVoid",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DVoid" "', argument " "1"" of type '" "UnaryFunction1D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVoid_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVoid_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVoid_getName" "', argument " "1"" of type '" "UnaryFunction1D<void > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<void > const *)arg1)->UnaryFunction1D<void >::getName();
+        } else {
+          result = ((UnaryFunction1D<void > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVoid___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVoid___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVoid___call__" "', argument " "1"" of type '" "UnaryFunction1D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DVoid___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DVoid___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->UnaryFunction1D<void >::operator ()(*arg2);
+        } else {
+          (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVoid_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVoid_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVoid_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DVoid_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVoid_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVoid_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVoid_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<void > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<void > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DVoid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<void > *arg1 = (UnaryFunction1D<void > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DVoid",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTvoid_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DVoid" "', argument " "1"" of type '" "UnaryFunction1D<void > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<void > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DVoid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTvoid_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DUnsigned__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<unsigned int > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DUnsigned",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<unsigned int > *)new SwigDirector_UnaryFunction1DUnsigned(arg1); 
+      } else {
+        result = (UnaryFunction1D<unsigned int > *)new UnaryFunction1D<unsigned int >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DUnsigned__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<unsigned int > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DUnsigned",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DUnsigned" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<unsigned int > *)new SwigDirector_UnaryFunction1DUnsigned(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<unsigned int > *)new UnaryFunction1D<unsigned int >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DUnsigned(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DUnsigned__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DUnsigned__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DUnsigned'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(unsigned int)>(PyObject *)\n    UnaryFunction1D<(unsigned int)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DUnsigned",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DUnsigned" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DUnsigned_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DUnsigned_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DUnsigned_getName" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<unsigned int > const *)arg1)->UnaryFunction1D<unsigned int >::getName();
+        } else {
+          result = ((UnaryFunction1D<unsigned int > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DUnsigned___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DUnsigned___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DUnsigned___call__" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DUnsigned___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DUnsigned___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (unsigned int)(arg1)->UnaryFunction1D<unsigned int >::operator ()(*arg2);
+        } else {
+          result = (unsigned int)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DUnsigned_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DUnsigned_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DUnsigned_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DUnsigned_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DUnsigned_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DUnsigned_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DUnsigned_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<unsigned int > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<unsigned int > *arg1 = (UnaryFunction1D<unsigned int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DUnsigned",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DUnsigned" "', argument " "1"" of type '" "UnaryFunction1D<unsigned int > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<unsigned int > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DUnsigned_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTunsigned_int_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DFloat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<float > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DFloat",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<float > *)new SwigDirector_UnaryFunction1DFloat(arg1); 
+      } else {
+        result = (UnaryFunction1D<float > *)new UnaryFunction1D<float >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DFloat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<float > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DFloat",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DFloat" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<float > *)new SwigDirector_UnaryFunction1DFloat(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<float > *)new UnaryFunction1D<float >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTfloat_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DFloat(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DFloat__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DFloat__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DFloat'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(float)>(PyObject *)\n    UnaryFunction1D<(float)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DFloat",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DFloat" "', argument " "1"" of type '" "UnaryFunction1D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DFloat_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DFloat_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DFloat_getName" "', argument " "1"" of type '" "UnaryFunction1D<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<float > const *)arg1)->UnaryFunction1D<float >::getName();
+        } else {
+          result = ((UnaryFunction1D<float > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DFloat___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DFloat___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DFloat___call__" "', argument " "1"" of type '" "UnaryFunction1D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DFloat___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DFloat___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (float)(arg1)->UnaryFunction1D<float >::operator ()(*arg2);
+        } else {
+          result = (float)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DFloat_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DFloat_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DFloat_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DFloat_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DFloat_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DFloat_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DFloat_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<float > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<float > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<float > *arg1 = (UnaryFunction1D<float > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DFloat",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTfloat_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DFloat" "', argument " "1"" of type '" "UnaryFunction1D<float > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<float > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DFloat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTfloat_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<double > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DDouble",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<double > *)new SwigDirector_UnaryFunction1DDouble(arg1); 
+      } else {
+        result = (UnaryFunction1D<double > *)new UnaryFunction1D<double >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<double > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DDouble",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DDouble" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<double > *)new SwigDirector_UnaryFunction1DDouble(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<double > *)new UnaryFunction1D<double >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTdouble_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DDouble(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DDouble__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DDouble__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DDouble'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(double)>(PyObject *)\n    UnaryFunction1D<(double)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DDouble",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DDouble" "', argument " "1"" of type '" "UnaryFunction1D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DDouble_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DDouble_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DDouble_getName" "', argument " "1"" of type '" "UnaryFunction1D<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<double > const *)arg1)->UnaryFunction1D<double >::getName();
+        } else {
+          result = ((UnaryFunction1D<double > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DDouble___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DDouble___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DDouble___call__" "', argument " "1"" of type '" "UnaryFunction1D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DDouble___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DDouble___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (double)(arg1)->UnaryFunction1D<double >::operator ()(*arg2);
+        } else {
+          result = (double)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DDouble_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DDouble_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DDouble_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DDouble_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DDouble_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DDouble_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DDouble_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<double > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<double > *arg1 = (UnaryFunction1D<double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DDouble",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTdouble_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DDouble" "', argument " "1"" of type '" "UnaryFunction1D<double > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<double > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTdouble_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec2f__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<Geometry::Vec2f > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DVec2f",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<Geometry::Vec2f > *)new SwigDirector_UnaryFunction1DVec2f(arg1); 
+      } else {
+        result = (UnaryFunction1D<Geometry::Vec2f > *)new UnaryFunction1D<Geometry::Vec2f >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec2f__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<Geometry::Vec2f > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DVec2f",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DVec2f" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<Geometry::Vec2f > *)new SwigDirector_UnaryFunction1DVec2f(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<Geometry::Vec2f > *)new UnaryFunction1D<Geometry::Vec2f >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec2f(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DVec2f__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DVec2f__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DVec2f'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(Geometry::Vec2f)>(PyObject *)\n    UnaryFunction1D<(Geometry::Vec2f)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DVec2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DVec2f" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec2f_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVec2f_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec2f_getName" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<Geometry::Vec2f > const *)arg1)->UnaryFunction1D<VecMat::Vec2<float > >::getName();
+        } else {
+          result = ((UnaryFunction1D<Geometry::Vec2f > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec2f___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  VecMat::Vec2<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVec2f___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec2f___call__" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DVec2f___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DVec2f___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (arg1)->UnaryFunction1D<VecMat::Vec2<float > >::operator ()(*arg2);
+        } else {
+          result = (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec2<float >(static_cast< const VecMat::Vec2<float >& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec2f_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVec2f_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec2f_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DVec2f_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec2f_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVec2f_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec2f_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<Geometry::Vec2f > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec2f > *arg1 = (UnaryFunction1D<Geometry::Vec2f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DVec2f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DVec2f" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec2f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec2f > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DVec2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec3f__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryFunction1D<Geometry::Vec3f > *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DVec3f",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<Geometry::Vec3f > *)new SwigDirector_UnaryFunction1DVec3f(arg1); 
+      } else {
+        result = (UnaryFunction1D<Geometry::Vec3f > *)new UnaryFunction1D<Geometry::Vec3f >(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec3f__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  IntegrationType arg2 ;
+  UnaryFunction1D<Geometry::Vec3f > *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_UnaryFunction1DVec3f",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UnaryFunction1DVec3f" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryFunction1D<Geometry::Vec3f > *)new SwigDirector_UnaryFunction1DVec3f(arg1,arg2); 
+      } else {
+        result = (UnaryFunction1D<Geometry::Vec3f > *)new UnaryFunction1D<Geometry::Vec3f >(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVec3f(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_UnaryFunction1DVec3f__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_UnaryFunction1DVec3f__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DVec3f'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(Geometry::Vec3f)>(PyObject *)\n    UnaryFunction1D<(Geometry::Vec3f)>(PyObject *,IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DVec3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DVec3f" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec3f_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVec3f_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec3f_getName" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryFunction1D<Geometry::Vec3f > const *)arg1)->UnaryFunction1D<VecMat::Vec3<float > >::getName();
+        } else {
+          result = ((UnaryFunction1D<Geometry::Vec3f > const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec3f___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  VecMat::Vec3<float > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVec3f___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec3f___call__" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DVec3f___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DVec3f___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (arg1)->UnaryFunction1D<VecMat::Vec3<float > >::operator ()(*arg2);
+        } else {
+          result = (arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec3<float >(static_cast< const VecMat::Vec3<float >& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec3f_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVec3f_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec3f_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DVec3f_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVec3f_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVec3f_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVec3f_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<Geometry::Vec3f > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryFunction1DVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<Geometry::Vec3f > *arg1 = (UnaryFunction1D<Geometry::Vec3f > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryFunction1DVec3f",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryFunction1DVec3f" "', argument " "1"" of type '" "UnaryFunction1D<Geometry::Vec3f > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<Geometry::Vec3f > * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DVec3f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVectorViewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_UnaryFunction1DVectorViewShape")) SWIG_fail;
+  {
+    try {
+      result = (UnaryFunction1D<std::vector<ViewShape * > > *)new UnaryFunction1D<std::vector<ViewShape * > >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVectorViewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  UnaryFunction1D<std::vector<ViewShape * > > *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryFunction1DVectorViewShape",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnaryFunction1DVectorViewShape" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (UnaryFunction1D<std::vector<ViewShape * > > *)new UnaryFunction1D<std::vector<ViewShape * > >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UnaryFunction1DVectorViewShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_UnaryFunction1DVectorViewShape__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_UnaryFunction1DVectorViewShape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_UnaryFunction1DVectorViewShape'.\n  Possible C/C++ prototypes are:\n    UnaryFunction1D<(std::vector<(p.ViewShape)>)>()\n    UnaryFunction1D<(std::vector<(p.ViewShape)>)>(IntegrationType)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryFunction1DVectorViewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *arg1 = (UnaryFunction1D<std::vector<ViewShape * > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryFunction1DVectorViewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryFunction1DVectorViewShape" "', argument " "1"" of type '" "UnaryFunction1D<std::vector<ViewShape * > > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<std::vector<ViewShape * > > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVectorViewShape_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *arg1 = (UnaryFunction1D<std::vector<ViewShape * > > *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVectorViewShape_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVectorViewShape_getName" "', argument " "1"" of type '" "UnaryFunction1D<std::vector<ViewShape * > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<std::vector<ViewShape * > > * >(argp1);
+  {
+    try {
+      result = ((UnaryFunction1D<std::vector<ViewShape * > > const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVectorViewShape___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *arg1 = (UnaryFunction1D<std::vector<ViewShape * > > *) 0 ;
+  Interface1D *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVectorViewShape___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVectorViewShape___call__" "', argument " "1"" of type '" "UnaryFunction1D<std::vector<ViewShape * > > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<std::vector<ViewShape * > > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryFunction1DVectorViewShape___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryFunction1DVectorViewShape___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVectorViewShape_setIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *arg1 = (UnaryFunction1D<std::vector<ViewShape * > > *) 0 ;
+  IntegrationType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryFunction1DVectorViewShape_setIntegrationType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVectorViewShape_setIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<std::vector<ViewShape * > > *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<std::vector<ViewShape * > > * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnaryFunction1DVectorViewShape_setIntegrationType" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      (arg1)->setIntegrationType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryFunction1DVectorViewShape_getIntegrationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction1D<std::vector<ViewShape * > > *arg1 = (UnaryFunction1D<std::vector<ViewShape * > > *) 0 ;
+  IntegrationType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryFunction1DVectorViewShape_getIntegrationType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryFunction1DVectorViewShape_getIntegrationType" "', argument " "1"" of type '" "UnaryFunction1D<std::vector<ViewShape * > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction1D<std::vector<ViewShape * > > * >(argp1);
+  {
+    try {
+      result = (IntegrationType)((UnaryFunction1D<std::vector<ViewShape * > > const *)arg1)->getIntegrationType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryFunction1DVectorViewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetXF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetXF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetXF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetXF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetXF1D *)new Functions1D::GetXF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetXF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetXF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetXF1D *arg1 = (Functions1D::GetXF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetXF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetXF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetXF1D_getName" "', argument " "1"" of type '" "Functions1D::GetXF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetXF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetXF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetXF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetXF1D *arg1 = (Functions1D::GetXF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetXF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetXF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetXF1D___call__" "', argument " "1"" of type '" "Functions1D::GetXF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetXF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetXF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetXF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetXF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetXF1D *arg1 = (Functions1D::GetXF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetXF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetXF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetXF1D" "', argument " "1"" of type '" "Functions1D::GetXF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetXF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetXF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetXF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetYF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetYF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetYF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetYF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetYF1D *)new Functions1D::GetYF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetYF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetYF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetYF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetYF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetYF1D *)new Functions1D::GetYF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetYF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetYF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_GetYF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetYF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetYF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetYF1D(IntegrationType)\n    Functions1D::GetYF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetYF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetYF1D *arg1 = (Functions1D::GetYF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetYF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetYF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetYF1D_getName" "', argument " "1"" of type '" "Functions1D::GetYF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetYF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetYF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetYF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetYF1D *arg1 = (Functions1D::GetYF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetYF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetYF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetYF1D___call__" "', argument " "1"" of type '" "Functions1D::GetYF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetYF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetYF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetYF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetYF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetYF1D *arg1 = (Functions1D::GetYF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetYF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetYF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetYF1D" "', argument " "1"" of type '" "Functions1D::GetYF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetYF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetYF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetYF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetZF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetZF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetZF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetZF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetZF1D *)new Functions1D::GetZF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetZF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetZF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetZF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetZF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetZF1D *)new Functions1D::GetZF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetZF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetZF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_GetZF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetZF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetZF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetZF1D(IntegrationType)\n    Functions1D::GetZF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetZF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetZF1D *arg1 = (Functions1D::GetZF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetZF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetZF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetZF1D_getName" "', argument " "1"" of type '" "Functions1D::GetZF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetZF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetZF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetZF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetZF1D *arg1 = (Functions1D::GetZF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetZF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetZF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetZF1D___call__" "', argument " "1"" of type '" "Functions1D::GetZF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetZF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetZF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetZF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetZF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetZF1D *arg1 = (Functions1D::GetZF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetZF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetZF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetZF1D" "', argument " "1"" of type '" "Functions1D::GetZF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetZF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetZF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetZF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedXF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetProjectedXF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetProjectedXF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetProjectedXF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetProjectedXF1D *)new Functions1D::GetProjectedXF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedXF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedXF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedXF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedXF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetProjectedXF1D *)new Functions1D::GetProjectedXF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedXF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedXF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_GetProjectedXF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetProjectedXF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetProjectedXF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetProjectedXF1D(IntegrationType)\n    Functions1D::GetProjectedXF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedXF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedXF1D *arg1 = (Functions1D::GetProjectedXF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedXF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedXF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedXF1D_getName" "', argument " "1"" of type '" "Functions1D::GetProjectedXF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedXF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetProjectedXF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedXF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedXF1D *arg1 = (Functions1D::GetProjectedXF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedXF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedXF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedXF1D___call__" "', argument " "1"" of type '" "Functions1D::GetProjectedXF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedXF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedXF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedXF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedXF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedXF1D *arg1 = (Functions1D::GetProjectedXF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedXF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedXF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedXF1D" "', argument " "1"" of type '" "Functions1D::GetProjectedXF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedXF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedXF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetProjectedXF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedYF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetProjectedYF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetProjectedYF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetProjectedYF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetProjectedYF1D *)new Functions1D::GetProjectedYF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedYF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedYF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedYF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedYF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetProjectedYF1D *)new Functions1D::GetProjectedYF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedYF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedYF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_GetProjectedYF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetProjectedYF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetProjectedYF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetProjectedYF1D(IntegrationType)\n    Functions1D::GetProjectedYF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedYF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedYF1D *arg1 = (Functions1D::GetProjectedYF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedYF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedYF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedYF1D_getName" "', argument " "1"" of type '" "Functions1D::GetProjectedYF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedYF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetProjectedYF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedYF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedYF1D *arg1 = (Functions1D::GetProjectedYF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedYF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedYF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedYF1D___call__" "', argument " "1"" of type '" "Functions1D::GetProjectedYF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedYF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedYF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedYF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedYF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedYF1D *arg1 = (Functions1D::GetProjectedYF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedYF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedYF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedYF1D" "', argument " "1"" of type '" "Functions1D::GetProjectedYF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedYF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedYF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetProjectedYF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedZF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::GetProjectedZF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetProjectedZF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetProjectedZF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::GetProjectedZF1D *)new Functions1D::GetProjectedZF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedZF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedZF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedZF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetProjectedZF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetProjectedZF1D *)new Functions1D::GetProjectedZF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetProjectedZF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetProjectedZF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_GetProjectedZF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetProjectedZF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetProjectedZF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetProjectedZF1D(IntegrationType)\n    Functions1D::GetProjectedZF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedZF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedZF1D *arg1 = (Functions1D::GetProjectedZF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetProjectedZF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedZF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedZF1D_getName" "', argument " "1"" of type '" "Functions1D::GetProjectedZF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedZF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetProjectedZF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetProjectedZF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedZF1D *arg1 = (Functions1D::GetProjectedZF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetProjectedZF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedZF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetProjectedZF1D___call__" "', argument " "1"" of type '" "Functions1D::GetProjectedZF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedZF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetProjectedZF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetProjectedZF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetProjectedZF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetProjectedZF1D *arg1 = (Functions1D::GetProjectedZF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetProjectedZF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetProjectedZF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetProjectedZF1D" "', argument " "1"" of type '" "Functions1D::GetProjectedZF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetProjectedZF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetProjectedZF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetProjectedZF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Orientation2DF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::Orientation2DF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Orientation2DF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Orientation2DF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::Orientation2DF1D *)new Functions1D::Orientation2DF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Orientation2DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Orientation2DF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation2DF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Orientation2DF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::Orientation2DF1D *)new Functions1D::Orientation2DF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Orientation2DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Orientation2DF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Orientation2DF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Orientation2DF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Orientation2DF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::Orientation2DF1D(IntegrationType)\n    Functions1D::Orientation2DF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Orientation2DF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation2DF1D *arg1 = (Functions1D::Orientation2DF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Orientation2DF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation2DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Orientation2DF1D_getName" "', argument " "1"" of type '" "Functions1D::Orientation2DF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation2DF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::Orientation2DF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Orientation2DF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation2DF1D *arg1 = (Functions1D::Orientation2DF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Orientation2DF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation2DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Orientation2DF1D___call__" "', argument " "1"" of type '" "Functions1D::Orientation2DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation2DF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Orientation2DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Orientation2DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Orientation2DF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation2DF1D *arg1 = (Functions1D::Orientation2DF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Orientation2DF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation2DF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Orientation2DF1D" "', argument " "1"" of type '" "Functions1D::Orientation2DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation2DF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Orientation2DF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__Orientation2DF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Orientation3DF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::Orientation3DF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Orientation3DF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Orientation3DF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::Orientation3DF1D *)new Functions1D::Orientation3DF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Orientation3DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Orientation3DF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation3DF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Orientation3DF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::Orientation3DF1D *)new Functions1D::Orientation3DF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Orientation3DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Orientation3DF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Orientation3DF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Orientation3DF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Orientation3DF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::Orientation3DF1D(IntegrationType)\n    Functions1D::Orientation3DF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Orientation3DF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation3DF1D *arg1 = (Functions1D::Orientation3DF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Orientation3DF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation3DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Orientation3DF1D_getName" "', argument " "1"" of type '" "Functions1D::Orientation3DF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation3DF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::Orientation3DF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Orientation3DF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation3DF1D *arg1 = (Functions1D::Orientation3DF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Orientation3DF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation3DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Orientation3DF1D___call__" "', argument " "1"" of type '" "Functions1D::Orientation3DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation3DF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Orientation3DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Orientation3DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Orientation3DF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Orientation3DF1D *arg1 = (Functions1D::Orientation3DF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Orientation3DF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Orientation3DF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Orientation3DF1D" "', argument " "1"" of type '" "Functions1D::Orientation3DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Orientation3DF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Orientation3DF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__Orientation3DF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ZDiscontinuityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::ZDiscontinuityF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ZDiscontinuityF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ZDiscontinuityF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::ZDiscontinuityF1D *)new Functions1D::ZDiscontinuityF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ZDiscontinuityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ZDiscontinuityF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ZDiscontinuityF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::ZDiscontinuityF1D *)new Functions1D::ZDiscontinuityF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ZDiscontinuityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ZDiscontinuityF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ZDiscontinuityF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ZDiscontinuityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::ZDiscontinuityF1D(IntegrationType)\n    Functions1D::ZDiscontinuityF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ZDiscontinuityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ZDiscontinuityF1D *arg1 = (Functions1D::ZDiscontinuityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ZDiscontinuityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZDiscontinuityF1D_getName" "', argument " "1"" of type '" "Functions1D::ZDiscontinuityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ZDiscontinuityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::ZDiscontinuityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ZDiscontinuityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ZDiscontinuityF1D *arg1 = (Functions1D::ZDiscontinuityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ZDiscontinuityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZDiscontinuityF1D___call__" "', argument " "1"" of type '" "Functions1D::ZDiscontinuityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ZDiscontinuityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZDiscontinuityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZDiscontinuityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ZDiscontinuityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ZDiscontinuityF1D *arg1 = (Functions1D::ZDiscontinuityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ZDiscontinuityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ZDiscontinuityF1D" "', argument " "1"" of type '" "Functions1D::ZDiscontinuityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ZDiscontinuityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ZDiscontinuityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__ZDiscontinuityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::QuantitativeInvisibilityF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_QuantitativeInvisibilityF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuantitativeInvisibilityF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::QuantitativeInvisibilityF1D *)new Functions1D::QuantitativeInvisibilityF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::QuantitativeInvisibilityF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_QuantitativeInvisibilityF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::QuantitativeInvisibilityF1D *)new Functions1D::QuantitativeInvisibilityF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_QuantitativeInvisibilityF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_QuantitativeInvisibilityF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuantitativeInvisibilityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::QuantitativeInvisibilityF1D(IntegrationType)\n    Functions1D::QuantitativeInvisibilityF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::QuantitativeInvisibilityF1D *arg1 = (Functions1D::QuantitativeInvisibilityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:QuantitativeInvisibilityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityF1D_getName" "', argument " "1"" of type '" "Functions1D::QuantitativeInvisibilityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::QuantitativeInvisibilityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::QuantitativeInvisibilityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::QuantitativeInvisibilityF1D *arg1 = (Functions1D::QuantitativeInvisibilityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:QuantitativeInvisibilityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityF1D___call__" "', argument " "1"" of type '" "Functions1D::QuantitativeInvisibilityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::QuantitativeInvisibilityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuantitativeInvisibilityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuantitativeInvisibilityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (unsigned int)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_QuantitativeInvisibilityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::QuantitativeInvisibilityF1D *arg1 = (Functions1D::QuantitativeInvisibilityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuantitativeInvisibilityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantitativeInvisibilityF1D" "', argument " "1"" of type '" "Functions1D::QuantitativeInvisibilityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::QuantitativeInvisibilityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *QuantitativeInvisibilityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__QuantitativeInvisibilityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_CurveNatureF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::CurveNatureF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_CurveNatureF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CurveNatureF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::CurveNatureF1D *)new Functions1D::CurveNatureF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__CurveNatureF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurveNatureF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::CurveNatureF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_CurveNatureF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::CurveNatureF1D *)new Functions1D::CurveNatureF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__CurveNatureF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurveNatureF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_CurveNatureF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_CurveNatureF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CurveNatureF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::CurveNatureF1D(IntegrationType)\n    Functions1D::CurveNatureF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurveNatureF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::CurveNatureF1D *arg1 = (Functions1D::CurveNatureF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurveNatureF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__CurveNatureF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveNatureF1D_getName" "', argument " "1"" of type '" "Functions1D::CurveNatureF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::CurveNatureF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::CurveNatureF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurveNatureF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::CurveNatureF1D *arg1 = (Functions1D::CurveNatureF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurveNatureF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__CurveNatureF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurveNatureF1D___call__" "', argument " "1"" of type '" "Functions1D::CurveNatureF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::CurveNatureF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurveNatureF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurveNatureF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (Nature::EdgeNature)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CurveNatureF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::CurveNatureF1D *arg1 = (Functions1D::CurveNatureF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CurveNatureF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__CurveNatureF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurveNatureF1D" "', argument " "1"" of type '" "Functions1D::CurveNatureF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::CurveNatureF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CurveNatureF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__CurveNatureF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_TimeStampF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::TimeStampF1D *arg1 = (Functions1D::TimeStampF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TimeStampF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__TimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStampF1D_getName" "', argument " "1"" of type '" "Functions1D::TimeStampF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::TimeStampF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::TimeStampF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TimeStampF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::TimeStampF1D *arg1 = (Functions1D::TimeStampF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TimeStampF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__TimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStampF1D___call__" "', argument " "1"" of type '" "Functions1D::TimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::TimeStampF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_TimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::TimeStampF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_TimeStampF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::TimeStampF1D *)new Functions1D::TimeStampF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__TimeStampF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::TimeStampF1D *arg1 = (Functions1D::TimeStampF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeStampF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__TimeStampF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeStampF1D" "', argument " "1"" of type '" "Functions1D::TimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::TimeStampF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TimeStampF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__TimeStampF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_IncrementChainingTimeStampF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::IncrementChainingTimeStampF1D *arg1 = (Functions1D::IncrementChainingTimeStampF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:IncrementChainingTimeStampF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementChainingTimeStampF1D_getName" "', argument " "1"" of type '" "Functions1D::IncrementChainingTimeStampF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::IncrementChainingTimeStampF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::IncrementChainingTimeStampF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_IncrementChainingTimeStampF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::IncrementChainingTimeStampF1D *arg1 = (Functions1D::IncrementChainingTimeStampF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:IncrementChainingTimeStampF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncrementChainingTimeStampF1D___call__" "', argument " "1"" of type '" "Functions1D::IncrementChainingTimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::IncrementChainingTimeStampF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncrementChainingTimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncrementChainingTimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_IncrementChainingTimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::IncrementChainingTimeStampF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_IncrementChainingTimeStampF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::IncrementChainingTimeStampF1D *)new Functions1D::IncrementChainingTimeStampF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_IncrementChainingTimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::IncrementChainingTimeStampF1D *arg1 = (Functions1D::IncrementChainingTimeStampF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncrementChainingTimeStampF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncrementChainingTimeStampF1D" "', argument " "1"" of type '" "Functions1D::IncrementChainingTimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::IncrementChainingTimeStampF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *IncrementChainingTimeStampF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__IncrementChainingTimeStampF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ChainingTimeStampF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ChainingTimeStampF1D *arg1 = (Functions1D::ChainingTimeStampF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingTimeStampF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ChainingTimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingTimeStampF1D_getName" "', argument " "1"" of type '" "Functions1D::ChainingTimeStampF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ChainingTimeStampF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::ChainingTimeStampF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingTimeStampF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ChainingTimeStampF1D *arg1 = (Functions1D::ChainingTimeStampF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ChainingTimeStampF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ChainingTimeStampF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingTimeStampF1D___call__" "', argument " "1"" of type '" "Functions1D::ChainingTimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ChainingTimeStampF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainingTimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainingTimeStampF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingTimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ChainingTimeStampF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ChainingTimeStampF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::ChainingTimeStampF1D *)new Functions1D::ChainingTimeStampF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__ChainingTimeStampF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ChainingTimeStampF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::ChainingTimeStampF1D *arg1 = (Functions1D::ChainingTimeStampF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainingTimeStampF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__ChainingTimeStampF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainingTimeStampF1D" "', argument " "1"" of type '" "Functions1D::ChainingTimeStampF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::ChainingTimeStampF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ChainingTimeStampF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__ChainingTimeStampF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Curvature2DAngleF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::Curvature2DAngleF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Curvature2DAngleF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Curvature2DAngleF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::Curvature2DAngleF1D *)new Functions1D::Curvature2DAngleF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curvature2DAngleF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Curvature2DAngleF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Curvature2DAngleF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::Curvature2DAngleF1D *)new Functions1D::Curvature2DAngleF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curvature2DAngleF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Curvature2DAngleF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Curvature2DAngleF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Curvature2DAngleF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::Curvature2DAngleF1D(IntegrationType)\n    Functions1D::Curvature2DAngleF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curvature2DAngleF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Curvature2DAngleF1D *arg1 = (Functions1D::Curvature2DAngleF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curvature2DAngleF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curvature2DAngleF1D_getName" "', argument " "1"" of type '" "Functions1D::Curvature2DAngleF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Curvature2DAngleF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::Curvature2DAngleF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curvature2DAngleF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Curvature2DAngleF1D *arg1 = (Functions1D::Curvature2DAngleF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curvature2DAngleF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curvature2DAngleF1D___call__" "', argument " "1"" of type '" "Functions1D::Curvature2DAngleF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Curvature2DAngleF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curvature2DAngleF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Curvature2DAngleF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Curvature2DAngleF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Curvature2DAngleF1D *arg1 = (Functions1D::Curvature2DAngleF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Curvature2DAngleF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Curvature2DAngleF1D" "', argument " "1"" of type '" "Functions1D::Curvature2DAngleF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Curvature2DAngleF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Curvature2DAngleF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__Curvature2DAngleF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Normal2DF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  IntegrationType arg1 ;
+  Functions1D::Normal2DF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Normal2DF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Normal2DF1D" "', argument " "1"" of type '" "IntegrationType""'");
+  } 
+  arg1 = static_cast< IntegrationType >(val1);
+  {
+    try {
+      result = (Functions1D::Normal2DF1D *)new Functions1D::Normal2DF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Normal2DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Normal2DF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Normal2DF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Normal2DF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::Normal2DF1D *)new Functions1D::Normal2DF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__Normal2DF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Normal2DF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Normal2DF1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_Normal2DF1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Normal2DF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::Normal2DF1D(IntegrationType)\n    Functions1D::Normal2DF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Normal2DF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Normal2DF1D *arg1 = (Functions1D::Normal2DF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Normal2DF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Normal2DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Normal2DF1D_getName" "', argument " "1"" of type '" "Functions1D::Normal2DF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Normal2DF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::Normal2DF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Normal2DF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Normal2DF1D *arg1 = (Functions1D::Normal2DF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Normal2DF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Normal2DF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Normal2DF1D___call__" "', argument " "1"" of type '" "Functions1D::Normal2DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Normal2DF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Normal2DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Normal2DF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Normal2DF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::Normal2DF1D *arg1 = (Functions1D::Normal2DF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Normal2DF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__Normal2DF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Normal2DF1D" "', argument " "1"" of type '" "Functions1D::Normal2DF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::Normal2DF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Normal2DF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__Normal2DF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetShapeF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetShapeF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetShapeF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetShapeF1D *)new Functions1D::GetShapeF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetShapeF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetShapeF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetShapeF1D *arg1 = (Functions1D::GetShapeF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetShapeF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetShapeF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShapeF1D_getName" "', argument " "1"" of type '" "Functions1D::GetShapeF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetShapeF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetShapeF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetShapeF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetShapeF1D *arg1 = (Functions1D::GetShapeF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetShapeF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetShapeF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetShapeF1D___call__" "', argument " "1"" of type '" "Functions1D::GetShapeF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetShapeF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetShapeF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetShapeF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetShapeF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetShapeF1D *arg1 = (Functions1D::GetShapeF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetShapeF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetShapeF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetShapeF1D" "', argument " "1"" of type '" "Functions1D::GetShapeF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetShapeF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetShapeF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetShapeF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetOccludersF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludersF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetOccludersF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetOccludersF1D *)new Functions1D::GetOccludersF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetOccludersF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludersF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludersF1D *arg1 = (Functions1D::GetOccludersF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetOccludersF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludersF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludersF1D_getName" "', argument " "1"" of type '" "Functions1D::GetOccludersF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludersF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetOccludersF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludersF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludersF1D *arg1 = (Functions1D::GetOccludersF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetOccludersF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludersF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludersF1D___call__" "', argument " "1"" of type '" "Functions1D::GetOccludersF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludersF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOccludersF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOccludersF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetOccludersF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludersF1D *arg1 = (Functions1D::GetOccludersF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetOccludersF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludersF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetOccludersF1D" "', argument " "1"" of type '" "Functions1D::GetOccludersF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludersF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetOccludersF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetOccludersF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetOccludeeF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludeeF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_GetOccludeeF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::GetOccludeeF1D *)new Functions1D::GetOccludeeF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetOccludeeF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludeeF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludeeF1D *arg1 = (Functions1D::GetOccludeeF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetOccludeeF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludeeF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludeeF1D_getName" "', argument " "1"" of type '" "Functions1D::GetOccludeeF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludeeF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetOccludeeF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetOccludeeF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludeeF1D *arg1 = (Functions1D::GetOccludeeF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  std::vector<ViewShape *,std::allocator<ViewShape * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetOccludeeF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludeeF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetOccludeeF1D___call__" "', argument " "1"" of type '" "Functions1D::GetOccludeeF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludeeF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetOccludeeF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetOccludeeF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = swig::from(static_cast< std::vector<ViewShape*,std::allocator<ViewShape * > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetOccludeeF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetOccludeeF1D *arg1 = (Functions1D::GetOccludeeF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetOccludeeF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetOccludeeF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetOccludeeF1D" "', argument " "1"" of type '" "Functions1D::GetOccludeeF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetOccludeeF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetOccludeeF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetOccludeeF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Module_setAlwaysRefresh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool arg1 ;
+  bool val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Module_setAlwaysRefresh",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_bool(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Module_setAlwaysRefresh" "', argument " "1"" of type '" "bool""'");
+  } 
+  arg1 = static_cast< bool >(val1);
+  {
+    try {
+      Module::setAlwaysRefresh(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setAlwaysRefresh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_setAlwaysRefresh")) SWIG_fail;
+  {
+    try {
+      Module::setAlwaysRefresh();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setAlwaysRefresh(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_Module_setAlwaysRefresh__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_bool(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_Module_setAlwaysRefresh__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Module_setAlwaysRefresh'.\n  Possible C/C++ prototypes are:\n    setAlwaysRefresh(bool)\n    Module::setAlwaysRefresh()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setCausal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool arg1 ;
+  bool val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Module_setCausal",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_bool(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Module_setCausal" "', argument " "1"" of type '" "bool""'");
+  } 
+  arg1 = static_cast< bool >(val1);
+  {
+    try {
+      Module::setCausal(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setCausal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_setCausal")) SWIG_fail;
+  {
+    try {
+      Module::setCausal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setCausal(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_Module_setCausal__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_bool(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_Module_setCausal__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Module_setCausal'.\n  Possible C/C++ prototypes are:\n    setCausal(bool)\n    Module::setCausal()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setDrawable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool arg1 ;
+  bool val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Module_setDrawable",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_bool(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Module_setDrawable" "', argument " "1"" of type '" "bool""'");
+  } 
+  arg1 = static_cast< bool >(val1);
+  {
+    try {
+      Module::setDrawable(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setDrawable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_setDrawable")) SWIG_fail;
+  {
+    try {
+      Module::setDrawable();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_setDrawable(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_Module_setDrawable__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_bool(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_Module_setDrawable__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Module_setDrawable'.\n  Possible C/C++ prototypes are:\n    setDrawable(bool)\n    Module::setDrawable()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_getAlwaysRefresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_getAlwaysRefresh")) SWIG_fail;
+  {
+    try {
+      result = (bool)Module::getAlwaysRefresh();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_getCausal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_getCausal")) SWIG_fail;
+  {
+    try {
+      result = (bool)Module::getCausal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Module_getDrawable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  bool result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Module_getDrawable")) SWIG_fail;
+  {
+    try {
+      result = (bool)Module::getDrawable();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Module *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Module")) SWIG_fail;
+  {
+    try {
+      result = (Module *)new Module();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Module, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Module *arg1 = (Module *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Module",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Module, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Module" "', argument " "1"" of type '" "Module *""'"); 
+  }
+  arg1 = reinterpret_cast< Module * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Module_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Module, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_DensityF0D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  Functions0D::DensityF0D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_DensityF0D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityF0D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  {
+    try {
+      result = (Functions0D::DensityF0D *)new Functions0D::DensityF0D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__DensityF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF0D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::DensityF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_DensityF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::DensityF0D *)new Functions0D::DensityF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__DensityF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF0D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_DensityF0D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_DensityF0D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DensityF0D'.\n  Possible C/C++ prototypes are:\n    Functions0D::DensityF0D(double)\n    Functions0D::DensityF0D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::DensityF0D *arg1 = (Functions0D::DensityF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:DensityF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__DensityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityF0D_getName" "', argument " "1"" of type '" "Functions0D::DensityF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::DensityF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::DensityF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::DensityF0D *arg1 = (Functions0D::DensityF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:DensityF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__DensityF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityF0D___call__" "', argument " "1"" of type '" "Functions0D::DensityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::DensityF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DensityF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_DensityF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::DensityF0D *arg1 = (Functions0D::DensityF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__DensityF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityF0D" "', argument " "1"" of type '" "Functions0D::DensityF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::DensityF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *DensityF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__DensityF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF0D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  Functions0D::LocalAverageDepthF0D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_LocalAverageDepthF0D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalAverageDepthF0D" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  {
+    try {
+      result = (Functions0D::LocalAverageDepthF0D *)new Functions0D::LocalAverageDepthF0D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF0D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::LocalAverageDepthF0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_LocalAverageDepthF0D")) SWIG_fail;
+  {
+    try {
+      result = (Functions0D::LocalAverageDepthF0D *)new Functions0D::LocalAverageDepthF0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF0D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_LocalAverageDepthF0D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_LocalAverageDepthF0D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LocalAverageDepthF0D'.\n  Possible C/C++ prototypes are:\n    Functions0D::LocalAverageDepthF0D(real)\n    Functions0D::LocalAverageDepthF0D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LocalAverageDepthF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::LocalAverageDepthF0D *arg1 = (Functions0D::LocalAverageDepthF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:LocalAverageDepthF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalAverageDepthF0D_getName" "', argument " "1"" of type '" "Functions0D::LocalAverageDepthF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::LocalAverageDepthF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::LocalAverageDepthF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LocalAverageDepthF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::LocalAverageDepthF0D *arg1 = (Functions0D::LocalAverageDepthF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:LocalAverageDepthF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalAverageDepthF0D___call__" "', argument " "1"" of type '" "Functions0D::LocalAverageDepthF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::LocalAverageDepthF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalAverageDepthF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalAverageDepthF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_LocalAverageDepthF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::LocalAverageDepthF0D *arg1 = (Functions0D::LocalAverageDepthF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_LocalAverageDepthF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalAverageDepthF0D" "', argument " "1"" of type '" "Functions0D::LocalAverageDepthF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::LocalAverageDepthF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *LocalAverageDepthF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__LocalAverageDepthF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ReadMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  Functions0D::ReadMapPixelF0D *result = 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ReadMapPixelF0D",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReadMapPixelF0D" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ReadMapPixelF0D" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      result = (Functions0D::ReadMapPixelF0D *)new Functions0D::ReadMapPixelF0D((char const *)arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__ReadMapPixelF0D, SWIG_POINTER_NEW |  0 );
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadMapPixelF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadMapPixelF0D *arg1 = (Functions0D::ReadMapPixelF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ReadMapPixelF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadMapPixelF0D_getName" "', argument " "1"" of type '" "Functions0D::ReadMapPixelF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadMapPixelF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::ReadMapPixelF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadMapPixelF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadMapPixelF0D *arg1 = (Functions0D::ReadMapPixelF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ReadMapPixelF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadMapPixelF0D___call__" "', argument " "1"" of type '" "Functions0D::ReadMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadMapPixelF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ReadMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadMapPixelF0D *arg1 = (Functions0D::ReadMapPixelF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReadMapPixelF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadMapPixelF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReadMapPixelF0D" "', argument " "1"" of type '" "Functions0D::ReadMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadMapPixelF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ReadMapPixelF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__ReadMapPixelF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ReadSteerableViewMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  int arg2 ;
+  Functions0D::ReadSteerableViewMapPixelF0D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ReadSteerableViewMapPixelF0D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ReadSteerableViewMapPixelF0D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ReadSteerableViewMapPixelF0D" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      result = (Functions0D::ReadSteerableViewMapPixelF0D *)new Functions0D::ReadSteerableViewMapPixelF0D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadSteerableViewMapPixelF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadSteerableViewMapPixelF0D *arg1 = (Functions0D::ReadSteerableViewMapPixelF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ReadSteerableViewMapPixelF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadSteerableViewMapPixelF0D_getName" "', argument " "1"" of type '" "Functions0D::ReadSteerableViewMapPixelF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadSteerableViewMapPixelF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::ReadSteerableViewMapPixelF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadSteerableViewMapPixelF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadSteerableViewMapPixelF0D *arg1 = (Functions0D::ReadSteerableViewMapPixelF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ReadSteerableViewMapPixelF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadSteerableViewMapPixelF0D___call__" "', argument " "1"" of type '" "Functions0D::ReadSteerableViewMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadSteerableViewMapPixelF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadSteerableViewMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadSteerableViewMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ReadSteerableViewMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadSteerableViewMapPixelF0D *arg1 = (Functions0D::ReadSteerableViewMapPixelF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReadSteerableViewMapPixelF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReadSteerableViewMapPixelF0D" "', argument " "1"" of type '" "Functions0D::ReadSteerableViewMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadSteerableViewMapPixelF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ReadSteerableViewMapPixelF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__ReadSteerableViewMapPixelF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ReadCompleteViewMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  Functions0D::ReadCompleteViewMapPixelF0D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ReadCompleteViewMapPixelF0D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ReadCompleteViewMapPixelF0D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (Functions0D::ReadCompleteViewMapPixelF0D *)new Functions0D::ReadCompleteViewMapPixelF0D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadCompleteViewMapPixelF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadCompleteViewMapPixelF0D *arg1 = (Functions0D::ReadCompleteViewMapPixelF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ReadCompleteViewMapPixelF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadCompleteViewMapPixelF0D_getName" "', argument " "1"" of type '" "Functions0D::ReadCompleteViewMapPixelF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadCompleteViewMapPixelF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::ReadCompleteViewMapPixelF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadCompleteViewMapPixelF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadCompleteViewMapPixelF0D *arg1 = (Functions0D::ReadCompleteViewMapPixelF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ReadCompleteViewMapPixelF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadCompleteViewMapPixelF0D___call__" "', argument " "1"" of type '" "Functions0D::ReadCompleteViewMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadCompleteViewMapPixelF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadCompleteViewMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadCompleteViewMapPixelF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ReadCompleteViewMapPixelF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::ReadCompleteViewMapPixelF0D *arg1 = (Functions0D::ReadCompleteViewMapPixelF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReadCompleteViewMapPixelF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReadCompleteViewMapPixelF0D" "', argument " "1"" of type '" "Functions0D::ReadCompleteViewMapPixelF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::ReadCompleteViewMapPixelF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ReadCompleteViewMapPixelF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__ReadCompleteViewMapPixelF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetViewMapGradientNormF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  Functions0D::GetViewMapGradientNormF0D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetViewMapGradientNormF0D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetViewMapGradientNormF0D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (Functions0D::GetViewMapGradientNormF0D *)new Functions0D::GetViewMapGradientNormF0D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetViewMapGradientNormF0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetViewMapGradientNormF0D *arg1 = (Functions0D::GetViewMapGradientNormF0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetViewMapGradientNormF0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetViewMapGradientNormF0D_getName" "', argument " "1"" of type '" "Functions0D::GetViewMapGradientNormF0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetViewMapGradientNormF0D * >(argp1);
+  {
+    try {
+      result = ((Functions0D::GetViewMapGradientNormF0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetViewMapGradientNormF0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetViewMapGradientNormF0D *arg1 = (Functions0D::GetViewMapGradientNormF0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetViewMapGradientNormF0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetViewMapGradientNormF0D___call__" "', argument " "1"" of type '" "Functions0D::GetViewMapGradientNormF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetViewMapGradientNormF0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetViewMapGradientNormF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetViewMapGradientNormF0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (float)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetViewMapGradientNormF0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions0D::GetViewMapGradientNormF0D *arg1 = (Functions0D::GetViewMapGradientNormF0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetViewMapGradientNormF0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetViewMapGradientNormF0D" "', argument " "1"" of type '" "Functions0D::GetViewMapGradientNormF0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions0D::GetViewMapGradientNormF0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetViewMapGradientNormF0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions0D__GetViewMapGradientNormF0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_DensityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  IntegrationType arg2 ;
+  float arg3 ;
+  Functions1D::DensityF1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityF1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityF1D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityF1D" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (Functions1D::DensityF1D *)new Functions1D::DensityF1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__DensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  IntegrationType arg2 ;
+  Functions1D::DensityF1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityF1D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Functions1D::DensityF1D *)new Functions1D::DensityF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__DensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  Functions1D::DensityF1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_DensityF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityF1D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  {
+    try {
+      result = (Functions1D::DensityF1D *)new Functions1D::DensityF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__DensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF1D__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::DensityF1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_DensityF1D")) SWIG_fail;
+  {
+    try {
+      result = (Functions1D::DensityF1D *)new Functions1D::DensityF1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__DensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_DensityF1D__SWIG_3(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_DensityF1D__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_DensityF1D__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_DensityF1D__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DensityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::DensityF1D(double,IntegrationType,float)\n    Functions1D::DensityF1D(double,IntegrationType)\n    Functions1D::DensityF1D(double)\n    Functions1D::DensityF1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_DensityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::DensityF1D *arg1 = (Functions1D::DensityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__DensityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityF1D" "', argument " "1"" of type '" "Functions1D::DensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::DensityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::DensityF1D *arg1 = (Functions1D::DensityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:DensityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__DensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityF1D_getName" "', argument " "1"" of type '" "Functions1D::DensityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::DensityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::DensityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::DensityF1D *arg1 = (Functions1D::DensityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:DensityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__DensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityF1D___call__" "', argument " "1"" of type '" "Functions1D::DensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::DensityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *DensityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__DensityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  IntegrationType arg2 ;
+  Functions1D::LocalAverageDepthF1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_LocalAverageDepthF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalAverageDepthF1D" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalAverageDepthF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Functions1D::LocalAverageDepthF1D *)new Functions1D::LocalAverageDepthF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  Functions1D::LocalAverageDepthF1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_LocalAverageDepthF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LocalAverageDepthF1D" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  {
+    try {
+      result = (Functions1D::LocalAverageDepthF1D *)new Functions1D::LocalAverageDepthF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_LocalAverageDepthF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_LocalAverageDepthF1D__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_LocalAverageDepthF1D__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LocalAverageDepthF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::LocalAverageDepthF1D(real,IntegrationType)\n    Functions1D::LocalAverageDepthF1D(real)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LocalAverageDepthF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::LocalAverageDepthF1D *arg1 = (Functions1D::LocalAverageDepthF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:LocalAverageDepthF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalAverageDepthF1D_getName" "', argument " "1"" of type '" "Functions1D::LocalAverageDepthF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::LocalAverageDepthF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::LocalAverageDepthF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LocalAverageDepthF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::LocalAverageDepthF1D *arg1 = (Functions1D::LocalAverageDepthF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:LocalAverageDepthF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalAverageDepthF1D___call__" "', argument " "1"" of type '" "Functions1D::LocalAverageDepthF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::LocalAverageDepthF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalAverageDepthF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalAverageDepthF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_LocalAverageDepthF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::LocalAverageDepthF1D *arg1 = (Functions1D::LocalAverageDepthF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_LocalAverageDepthF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalAverageDepthF1D" "', argument " "1"" of type '" "Functions1D::LocalAverageDepthF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::LocalAverageDepthF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *LocalAverageDepthF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__LocalAverageDepthF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetCompleteViewMapDensityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  IntegrationType arg2 ;
+  float arg3 ;
+  Functions1D::GetCompleteViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_GetCompleteViewMapDensityF1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (Functions1D::GetCompleteViewMapDensityF1D *)new Functions1D::GetCompleteViewMapDensityF1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetCompleteViewMapDensityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  IntegrationType arg2 ;
+  Functions1D::GetCompleteViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_GetCompleteViewMapDensityF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Functions1D::GetCompleteViewMapDensityF1D *)new Functions1D::GetCompleteViewMapDensityF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetCompleteViewMapDensityF1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Functions1D::GetCompleteViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetCompleteViewMapDensityF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetCompleteViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Functions1D::GetCompleteViewMapDensityF1D *)new Functions1D::GetCompleteViewMapDensityF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetCompleteViewMapDensityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetCompleteViewMapDensityF1D__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_GetCompleteViewMapDensityF1D__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_GetCompleteViewMapDensityF1D__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetCompleteViewMapDensityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetCompleteViewMapDensityF1D(unsigned int,IntegrationType,float)\n    Functions1D::GetCompleteViewMapDensityF1D(unsigned int,IntegrationType)\n    Functions1D::GetCompleteViewMapDensityF1D(unsigned int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetCompleteViewMapDensityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetCompleteViewMapDensityF1D *arg1 = (Functions1D::GetCompleteViewMapDensityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetCompleteViewMapDensityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCompleteViewMapDensityF1D_getName" "', argument " "1"" of type '" "Functions1D::GetCompleteViewMapDensityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetCompleteViewMapDensityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetCompleteViewMapDensityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetCompleteViewMapDensityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetCompleteViewMapDensityF1D *arg1 = (Functions1D::GetCompleteViewMapDensityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetCompleteViewMapDensityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCompleteViewMapDensityF1D___call__" "', argument " "1"" of type '" "Functions1D::GetCompleteViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetCompleteViewMapDensityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetCompleteViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetCompleteViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetCompleteViewMapDensityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetCompleteViewMapDensityF1D *arg1 = (Functions1D::GetCompleteViewMapDensityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetCompleteViewMapDensityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetCompleteViewMapDensityF1D" "', argument " "1"" of type '" "Functions1D::GetCompleteViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetCompleteViewMapDensityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetCompleteViewMapDensityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetCompleteViewMapDensityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetDirectionalViewMapDensityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  unsigned int arg2 ;
+  IntegrationType arg3 ;
+  float arg4 ;
+  Functions1D::GetDirectionalViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_GetDirectionalViewMapDensityF1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "3"" of type '" "IntegrationType""'");
+  } 
+  arg3 = static_cast< IntegrationType >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      result = (Functions1D::GetDirectionalViewMapDensityF1D *)new Functions1D::GetDirectionalViewMapDensityF1D(arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetDirectionalViewMapDensityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  unsigned int arg2 ;
+  IntegrationType arg3 ;
+  Functions1D::GetDirectionalViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_GetDirectionalViewMapDensityF1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "3"" of type '" "IntegrationType""'");
+  } 
+  arg3 = static_cast< IntegrationType >(val3);
+  {
+    try {
+      result = (Functions1D::GetDirectionalViewMapDensityF1D *)new Functions1D::GetDirectionalViewMapDensityF1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetDirectionalViewMapDensityF1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  unsigned int arg2 ;
+  Functions1D::GetDirectionalViewMapDensityF1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_GetDirectionalViewMapDensityF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetDirectionalViewMapDensityF1D" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      result = (Functions1D::GetDirectionalViewMapDensityF1D *)new Functions1D::GetDirectionalViewMapDensityF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetDirectionalViewMapDensityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_GetDirectionalViewMapDensityF1D__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_GetDirectionalViewMapDensityF1D__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_GetDirectionalViewMapDensityF1D__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetDirectionalViewMapDensityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetDirectionalViewMapDensityF1D(unsigned int,unsigned int,IntegrationType,float)\n    Functions1D::GetDirectionalViewMapDensityF1D(unsigned int,unsigned int,IntegrationType)\n    Functions1D::GetDirectionalViewMapDensityF1D(unsigned int,unsigned int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetDirectionalViewMapDensityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetDirectionalViewMapDensityF1D *arg1 = (Functions1D::GetDirectionalViewMapDensityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetDirectionalViewMapDensityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDirectionalViewMapDensityF1D_getName" "', argument " "1"" of type '" "Functions1D::GetDirectionalViewMapDensityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetDirectionalViewMapDensityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetDirectionalViewMapDensityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetDirectionalViewMapDensityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetDirectionalViewMapDensityF1D *arg1 = (Functions1D::GetDirectionalViewMapDensityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  double result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetDirectionalViewMapDensityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDirectionalViewMapDensityF1D___call__" "', argument " "1"" of type '" "Functions1D::GetDirectionalViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetDirectionalViewMapDensityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDirectionalViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDirectionalViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (double)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetDirectionalViewMapDensityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetDirectionalViewMapDensityF1D *arg1 = (Functions1D::GetDirectionalViewMapDensityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetDirectionalViewMapDensityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetDirectionalViewMapDensityF1D" "', argument " "1"" of type '" "Functions1D::GetDirectionalViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetDirectionalViewMapDensityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetDirectionalViewMapDensityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetDirectionalViewMapDensityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetSteerableViewMapDensityF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  float arg3 ;
+  Functions1D::GetSteerableViewMapDensityF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_GetSteerableViewMapDensityF1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (Functions1D::GetSteerableViewMapDensityF1D *)new Functions1D::GetSteerableViewMapDensityF1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetSteerableViewMapDensityF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  Functions1D::GetSteerableViewMapDensityF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_GetSteerableViewMapDensityF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Functions1D::GetSteerableViewMapDensityF1D *)new Functions1D::GetSteerableViewMapDensityF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetSteerableViewMapDensityF1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  Functions1D::GetSteerableViewMapDensityF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetSteerableViewMapDensityF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetSteerableViewMapDensityF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (Functions1D::GetSteerableViewMapDensityF1D *)new Functions1D::GetSteerableViewMapDensityF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetSteerableViewMapDensityF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetSteerableViewMapDensityF1D__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_GetSteerableViewMapDensityF1D__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_GetSteerableViewMapDensityF1D__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetSteerableViewMapDensityF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetSteerableViewMapDensityF1D(int,IntegrationType,float)\n    Functions1D::GetSteerableViewMapDensityF1D(int,IntegrationType)\n    Functions1D::GetSteerableViewMapDensityF1D(int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetSteerableViewMapDensityF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetSteerableViewMapDensityF1D *arg1 = (Functions1D::GetSteerableViewMapDensityF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetSteerableViewMapDensityF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetSteerableViewMapDensityF1D" "', argument " "1"" of type '" "Functions1D::GetSteerableViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetSteerableViewMapDensityF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetSteerableViewMapDensityF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetSteerableViewMapDensityF1D *arg1 = (Functions1D::GetSteerableViewMapDensityF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetSteerableViewMapDensityF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSteerableViewMapDensityF1D_getName" "', argument " "1"" of type '" "Functions1D::GetSteerableViewMapDensityF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetSteerableViewMapDensityF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetSteerableViewMapDensityF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetSteerableViewMapDensityF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetSteerableViewMapDensityF1D *arg1 = (Functions1D::GetSteerableViewMapDensityF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetSteerableViewMapDensityF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetSteerableViewMapDensityF1D___call__" "', argument " "1"" of type '" "Functions1D::GetSteerableViewMapDensityF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetSteerableViewMapDensityF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetSteerableViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetSteerableViewMapDensityF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetSteerableViewMapDensityF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetSteerableViewMapDensityF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GetViewMapGradientNormF1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  float arg3 ;
+  Functions1D::GetViewMapGradientNormF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_GetViewMapGradientNormF1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (Functions1D::GetViewMapGradientNormF1D *)new Functions1D::GetViewMapGradientNormF1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetViewMapGradientNormF1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  Functions1D::GetViewMapGradientNormF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_GetViewMapGradientNormF1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Functions1D::GetViewMapGradientNormF1D *)new Functions1D::GetViewMapGradientNormF1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetViewMapGradientNormF1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  Functions1D::GetViewMapGradientNormF1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GetViewMapGradientNormF1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GetViewMapGradientNormF1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (Functions1D::GetViewMapGradientNormF1D *)new Functions1D::GetViewMapGradientNormF1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_GetViewMapGradientNormF1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_GetViewMapGradientNormF1D__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_GetViewMapGradientNormF1D__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_GetViewMapGradientNormF1D__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_GetViewMapGradientNormF1D'.\n  Possible C/C++ prototypes are:\n    Functions1D::GetViewMapGradientNormF1D(int,IntegrationType,float)\n    Functions1D::GetViewMapGradientNormF1D(int,IntegrationType)\n    Functions1D::GetViewMapGradientNormF1D(int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetViewMapGradientNormF1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetViewMapGradientNormF1D *arg1 = (Functions1D::GetViewMapGradientNormF1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:GetViewMapGradientNormF1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetViewMapGradientNormF1D_getName" "', argument " "1"" of type '" "Functions1D::GetViewMapGradientNormF1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetViewMapGradientNormF1D * >(argp1);
+  {
+    try {
+      result = ((Functions1D::GetViewMapGradientNormF1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetViewMapGradientNormF1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetViewMapGradientNormF1D *arg1 = (Functions1D::GetViewMapGradientNormF1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GetViewMapGradientNormF1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetViewMapGradientNormF1D___call__" "', argument " "1"" of type '" "Functions1D::GetViewMapGradientNormF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetViewMapGradientNormF1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetViewMapGradientNormF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetViewMapGradientNormF1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (real)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GetViewMapGradientNormF1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Functions1D::GetViewMapGradientNormF1D *arg1 = (Functions1D::GetViewMapGradientNormF1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GetViewMapGradientNormF1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GetViewMapGradientNormF1D" "', argument " "1"" of type '" "Functions1D::GetViewMapGradientNormF1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Functions1D::GetViewMapGradientNormF1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GetViewMapGradientNormF1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Functions1D__GetViewMapGradientNormF1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_GetTimeStampCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":GetTimeStampCF")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)ContextFunctions::GetTimeStampCF();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetCanvasWidthCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":GetCanvasWidthCF")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)ContextFunctions::GetCanvasWidthCF();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetCanvasHeightCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":GetCanvasHeightCF")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)ContextFunctions::GetCanvasHeightCF();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LoadMapCF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  unsigned int arg3 ;
+  float arg4 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:LoadMapCF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadMapCF" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadMapCF" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoadMapCF" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LoadMapCF" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      ContextFunctions::LoadMapCF((char const *)arg1,(char const *)arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LoadMapCF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  unsigned int arg3 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:LoadMapCF",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadMapCF" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadMapCF" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LoadMapCF" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  {
+    try {
+      ContextFunctions::LoadMapCF((char const *)arg1,(char const *)arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LoadMapCF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:LoadMapCF",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadMapCF" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadMapCF" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      ContextFunctions::LoadMapCF((char const *)arg1,(char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LoadMapCF(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_LoadMapCF__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_LoadMapCF__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_LoadMapCF__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LoadMapCF'.\n  Possible C/C++ prototypes are:\n    ContextFunctions::LoadMapCF(char const *,char const *,unsigned int,float)\n    ContextFunctions::LoadMapCF(char const *,char const *,unsigned int)\n    ContextFunctions::LoadMapCF(char const *,char const *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadMapPixelCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  unsigned int arg3 ;
+  unsigned int arg4 ;
+  float result;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ReadMapPixelCF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadMapPixelCF" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReadMapPixelCF" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReadMapPixelCF" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReadMapPixelCF" "', argument " "4"" of type '" "unsigned int""'");
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  {
+    try {
+      result = (float)ContextFunctions::ReadMapPixelCF((char const *)arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadCompleteViewMapPixelCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  unsigned int arg2 ;
+  unsigned int arg3 ;
+  float result;
+  int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ReadCompleteViewMapPixelCF",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ReadCompleteViewMapPixelCF" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReadCompleteViewMapPixelCF" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReadCompleteViewMapPixelCF" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  {
+    try {
+      result = (float)ContextFunctions::ReadCompleteViewMapPixelCF(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ReadDirectionalViewMapPixelCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  int arg2 ;
+  unsigned int arg3 ;
+  unsigned int arg4 ;
+  float result;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ReadDirectionalViewMapPixelCF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ReadDirectionalViewMapPixelCF" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReadDirectionalViewMapPixelCF" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ReadDirectionalViewMapPixelCF" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReadDirectionalViewMapPixelCF" "', argument " "4"" of type '" "unsigned int""'");
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  {
+    try {
+      result = (float)ContextFunctions::ReadDirectionalViewMapPixelCF(arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GetSelectedFEdgeCF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FEdge *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":GetSelectedFEdgeCF")) SWIG_fail;
+  {
+    try {
+      result = (FEdge *)ContextFunctions::GetSelectedFEdgeCF();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_AdjacencyIterator")) SWIG_fail;
+  {
+    try {
+      result = (AdjacencyIterator *)new AdjacencyIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  AdjacencyIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_AdjacencyIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdjacencyIterator" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AdjacencyIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AdjacencyIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      result = (AdjacencyIterator *)new AdjacencyIterator(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  bool arg2 ;
+  AdjacencyIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_AdjacencyIterator",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdjacencyIterator" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AdjacencyIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      result = (AdjacencyIterator *)new AdjacencyIterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewVertex *arg1 = (ViewVertex *) 0 ;
+  AdjacencyIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_AdjacencyIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdjacencyIterator" "', argument " "1"" of type '" "ViewVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewVertex * >(argp1);
+  {
+    try {
+      result = (AdjacencyIterator *)new AdjacencyIterator(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = 0 ;
+  AdjacencyIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_AdjacencyIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_AdjacencyIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdjacencyIterator" "', argument " "1"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdjacencyIterator" "', argument " "1"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (AdjacencyIterator *)new AdjacencyIterator((AdjacencyIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_AdjacencyIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_AdjacencyIterator__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_AdjacencyIterator__SWIG_3(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_AdjacencyIterator__SWIG_4(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_AdjacencyIterator__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_AdjacencyIterator__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_AdjacencyIterator'.\n  Possible C/C++ prototypes are:\n    AdjacencyIterator()\n    AdjacencyIterator(ViewVertex *,bool,bool)\n    AdjacencyIterator(ViewVertex *,bool)\n    AdjacencyIterator(ViewVertex *)\n    AdjacencyIterator(AdjacencyIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_AdjacencyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdjacencyIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdjacencyIterator" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_isEnd" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_isBegin" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_isIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_isIncoming",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_isIncoming" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)((AdjacencyIterator const *)arg1)->isIncoming();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getObject" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)(arg1)->operator *();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator___deref__" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_increment" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getExactTypeName" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getId" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Nature::EdgeNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getNature" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (Nature::EdgeNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_userdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_userdata_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_userdata_set" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_userdata_set" "', argument " "2"" of type '" "void *""'"); 
+  }
+  if (arg1) (*arg1)->userdata = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_userdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  void *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_userdata_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_userdata_get" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  result = (void *) ((*arg1)->userdata);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_A" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_B" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_fedgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_fedgeA",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_fedgeA" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedgeA();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_fedgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_fedgeB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_fedgeB" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedgeB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_viewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_viewShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_viewShape" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->viewShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_aShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_aShape" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_aShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_aShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_aShape" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->aShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_aShape(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_AdjacencyIterator_aShape__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_AdjacencyIterator_aShape__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'AdjacencyIterator_aShape'.\n  Possible C/C++ prototypes are:\n    aShape()\n    aShape()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_isClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_isClosed",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_isClosed" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->isClosed();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getChainingTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getChainingTimeStamp" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->getChainingTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_bShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_bShape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_bShape" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(*arg1)->bShape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  std::vector<ViewShape * > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluders",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluders" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      {
+        std::vector<ViewShape * > &_result_ref = (*arg1)->occluders();
+        result = (std::vector<ViewShape * > *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_splittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Id *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_splittingId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_splittingId" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (Id *)(*arg1)->splittingId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Id, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setA" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setA" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewVertex *arg2 = (ViewVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setB" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setB" "', argument " "2"" of type '" "ViewVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Nature::EdgeNature arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned short val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setNature",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setNature" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_setNature" "', argument " "2"" of type '" "Nature::EdgeNature""'");
+  } 
+  arg2 = static_cast< Nature::EdgeNature >(val2);
+  {
+    try {
+      (*arg1)->setNature(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setFEdgeA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setFEdgeA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setFEdgeA" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setFEdgeA" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->setFEdgeA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setFEdgeB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setFEdgeB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setFEdgeB" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setFEdgeB" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (*arg1)->setFEdgeB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setShape" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->setShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setId" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdjacencyIterator_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_UpdateFEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_UpdateFEdges",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_UpdateFEdges" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      (*arg1)->UpdateFEdges();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setaShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setaShape",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setaShape" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setaShape" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->setaShape(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setQI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setQI",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setQI" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_setQI" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      (*arg1)->setQI(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setChainingTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setChainingTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setChainingTimeStamp" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_setChainingTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (*arg1)->setChainingTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_AddOccluder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  ViewShape *arg2 = (ViewShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_AddOccluder",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_AddOccluder" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewShape, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_AddOccluder" "', argument " "2"" of type '" "ViewShape *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewShape * >(argp2);
+  {
+    try {
+      (*arg1)->AddOccluder(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setSplittingId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Id *arg2 = (Id *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setSplittingId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setSplittingId" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Id, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_setSplittingId" "', argument " "2"" of type '" "Id *""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (*arg1)->setSplittingId(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_intersect_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:AdjacencyIterator_intersect_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_intersect_2d_area" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdjacencyIterator_intersect_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AdjacencyIterator_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdjacencyIterator_intersect_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)(*arg1)->intersect_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_include_in_2d_area(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  Geometry::Vec2r *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:AdjacencyIterator_include_in_2d_area",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_include_in_2d_area" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdjacencyIterator_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdjacencyIterator_include_in_2d_area" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AdjacencyIterator_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdjacencyIterator_include_in_2d_area" "', argument " "3"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2r * >(argp3);
+  {
+    try {
+      result = (bool)(*arg1)->include_in_2d_area((Geometry::Vec2r const &)*arg2,(Geometry::Vec2r const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getLength2D" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_qi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_qi",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_qi" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->qi();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluders_begin" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluders_end" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluders_size" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluders_empty" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occludee" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occluded_shape" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_occludee_empty" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_shape_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_shape_id",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_shape_id" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->shape_id();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_shape" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_shape_importance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_shape_importance",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_shape_importance" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->shape_importance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_verticesBegin" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_verticesEnd" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_pointsBegin" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (*arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_pointsBegin" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_AdjacencyIterator_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_AdjacencyIterator_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'AdjacencyIterator_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_pointsEnd" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (*arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_pointsEnd" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_AdjacencyIterator_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AdjacencyIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_AdjacencyIterator_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'AdjacencyIterator_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_getTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:AdjacencyIterator_getTimeStamp",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_getTimeStamp" "', argument " "1"" of type '" "AdjacencyIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  {
+    try {
+      result = (unsigned int)(*arg1)->getTimeStamp();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_AdjacencyIterator_setTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  AdjacencyIterator *arg1 = (AdjacencyIterator *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:AdjacencyIterator_setTimeStamp",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AdjacencyIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdjacencyIterator_setTimeStamp" "', argument " "1"" of type '" "AdjacencyIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< AdjacencyIterator * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AdjacencyIterator_setTimeStamp" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (*arg1)->setTimeStamp(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *AdjacencyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_AdjacencyIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ViewEdge *arg4 = (ViewEdge *) 0 ;
+  bool arg5 ;
+  ChainingIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainingIterator",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainingIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainingIterator" "', argument " "4"" of type '" "ViewEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< ViewEdge * >(argp4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainingIterator" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1,arg2,arg3,arg4,arg5); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator(arg2,arg3,arg4,arg5); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ViewEdge *arg4 = (ViewEdge *) 0 ;
+  ChainingIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainingIterator",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainingIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainingIterator" "', argument " "4"" of type '" "ViewEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< ViewEdge * >(argp4);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1,arg2,arg3,arg4); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator(arg2,arg3,arg4); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ChainingIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainingIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainingIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1,arg2,arg3); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator(arg2,arg3); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  ChainingIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainingIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1,arg2); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainingIterator *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ChainingIterator",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainingIterator *arg2 = 0 ;
+  ChainingIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainingIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ChainingIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "ChainingIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainingIterator" "', argument " "2"" of type '" "ChainingIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ChainingIterator * >(argp2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainingIterator *)new SwigDirector_ChainingIterator(arg1,(ChainingIterator const &)*arg2); 
+      } else {
+        result = (ChainingIterator *)new ChainingIterator((ChainingIterator const &)*arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainingIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainingIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_ChainingIterator__SWIG_4(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ChainingIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ChainingIterator__SWIG_5(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ChainingIterator__SWIG_3(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ChainingIterator__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ViewEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_ChainingIterator__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ViewEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_ChainingIterator__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ChainingIterator'.\n  Possible C/C++ prototypes are:\n    ChainingIterator(PyObject *,bool,bool,ViewEdge *,bool)\n    ChainingIterator(PyObject *,bool,bool,ViewEdge *)\n    ChainingIterator(PyObject *,bool,bool)\n    ChainingIterator(PyObject *,bool)\n    ChainingIterator(PyObject *)\n    ChainingIterator(PyObject *,ChainingIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_getExactTypeName" "', argument " "1"" of type '" "ChainingIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((ChainingIterator const *)arg1)->ChainingIterator::getExactTypeName();
+        } else {
+          result = ((ChainingIterator const *)arg1)->getExactTypeName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_init",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_init" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->ChainingIterator::init();
+        } else {
+          (arg1)->init();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_traverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  AdjacencyIterator *arg2 = 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ChainingIterator_traverse",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_traverse" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_AdjacencyIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainingIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainingIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< AdjacencyIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (ViewEdge *)(arg1)->ChainingIterator::traverse((AdjacencyIterator const &)*arg2);
+        } else {
+          result = (ViewEdge *)(arg1)->traverse((AdjacencyIterator const &)*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_getVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_getVertex" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->getVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_isIncrementing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_isIncrementing",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_isIncrementing" "', argument " "1"" of type '" "ChainingIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  {
+    try {
+      result = (bool)((ChainingIterator const *)arg1)->isIncrementing();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_increment" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->ChainingIterator::increment();
+        } else {
+          (arg1)->increment();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainingIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainingIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainingIterator_decrement" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          (arg1)->ChainingIterator::decrement();
+        } else {
+          (arg1)->decrement();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ChainingIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainingIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainingIterator" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_ChainingIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = (ChainingIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_ChainingIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainingIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ChainingIterator" "', argument " "1"" of type '" "ChainingIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ChainingIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ChainingIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  ViewEdge *arg3 = (ViewEdge *) 0 ;
+  bool arg4 ;
+  ChainSilhouetteIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainSilhouetteIterator",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainSilhouetteIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainSilhouetteIterator" "', argument " "3"" of type '" "ViewEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< ViewEdge * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainSilhouetteIterator" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainSilhouetteIterator *)new SwigDirector_ChainSilhouetteIterator(arg1,arg2,arg3,arg4); 
+      } else {
+        result = (ChainSilhouetteIterator *)new ChainSilhouetteIterator(arg2,arg3,arg4); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  ViewEdge *arg3 = (ViewEdge *) 0 ;
+  ChainSilhouetteIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainSilhouetteIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainSilhouetteIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainSilhouetteIterator" "', argument " "3"" of type '" "ViewEdge *""'"); 
+  }
+  arg3 = reinterpret_cast< ViewEdge * >(argp3);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainSilhouetteIterator *)new SwigDirector_ChainSilhouetteIterator(arg1,arg2,arg3); 
+      } else {
+        result = (ChainSilhouetteIterator *)new ChainSilhouetteIterator(arg2,arg3); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  ChainSilhouetteIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainSilhouetteIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainSilhouetteIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainSilhouetteIterator *)new SwigDirector_ChainSilhouetteIterator(arg1,arg2); 
+      } else {
+        result = (ChainSilhouetteIterator *)new ChainSilhouetteIterator(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainSilhouetteIterator *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ChainSilhouetteIterator",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainSilhouetteIterator *)new SwigDirector_ChainSilhouetteIterator(arg1); 
+      } else {
+        result = (ChainSilhouetteIterator *)new ChainSilhouetteIterator(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainSilhouetteIterator *arg2 = 0 ;
+  ChainSilhouetteIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainSilhouetteIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ChainSilhouetteIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainSilhouetteIterator" "', argument " "2"" of type '" "ChainSilhouetteIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainSilhouetteIterator" "', argument " "2"" of type '" "ChainSilhouetteIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ChainSilhouetteIterator * >(argp2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainSilhouetteIterator *)new SwigDirector_ChainSilhouetteIterator(arg1,(ChainSilhouetteIterator const &)*arg2); 
+      } else {
+        result = (ChainSilhouetteIterator *)new ChainSilhouetteIterator((ChainSilhouetteIterator const &)*arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainSilhouetteIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_ChainSilhouetteIterator__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ChainSilhouetteIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ChainSilhouetteIterator__SWIG_4(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ChainSilhouetteIterator__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ViewEdge, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_ChainSilhouetteIterator__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ViewEdge, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_ChainSilhouetteIterator__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ChainSilhouetteIterator'.\n  Possible C/C++ prototypes are:\n    ChainSilhouetteIterator(PyObject *,bool,ViewEdge *,bool)\n    ChainSilhouetteIterator(PyObject *,bool,ViewEdge *)\n    ChainSilhouetteIterator(PyObject *,bool)\n    ChainSilhouetteIterator(PyObject *)\n    ChainSilhouetteIterator(PyObject *,ChainSilhouetteIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainSilhouetteIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainSilhouetteIterator *arg1 = (ChainSilhouetteIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainSilhouetteIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainSilhouetteIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainSilhouetteIterator_getExactTypeName" "', argument " "1"" of type '" "ChainSilhouetteIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainSilhouetteIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((ChainSilhouetteIterator const *)arg1)->ChainSilhouetteIterator::getExactTypeName();
+        } else {
+          result = ((ChainSilhouetteIterator const *)arg1)->getExactTypeName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainSilhouetteIterator_traverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainSilhouetteIterator *arg1 = (ChainSilhouetteIterator *) 0 ;
+  AdjacencyIterator *arg2 = 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ChainSilhouetteIterator_traverse",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainSilhouetteIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainSilhouetteIterator_traverse" "', argument " "1"" of type '" "ChainSilhouetteIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainSilhouetteIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_AdjacencyIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainSilhouetteIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainSilhouetteIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< AdjacencyIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (ViewEdge *)(arg1)->ChainSilhouetteIterator::traverse((AdjacencyIterator const &)*arg2);
+        } else {
+          result = (ViewEdge *)(arg1)->traverse((AdjacencyIterator const &)*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ChainSilhouetteIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainSilhouetteIterator *arg1 = (ChainSilhouetteIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainSilhouetteIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainSilhouetteIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainSilhouetteIterator" "', argument " "1"" of type '" "ChainSilhouetteIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainSilhouetteIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_ChainSilhouetteIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainSilhouetteIterator *arg1 = (ChainSilhouetteIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_ChainSilhouetteIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainSilhouetteIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ChainSilhouetteIterator" "', argument " "1"" of type '" "ChainSilhouetteIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainSilhouetteIterator * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ChainSilhouetteIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ChainSilhouetteIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ViewEdge *arg4 = (ViewEdge *) 0 ;
+  bool arg5 ;
+  ChainPredicateIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "ViewEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< ViewEdge * >(argp4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainPredicateIterator" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,arg2,arg3,arg4,arg5); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(arg2,arg3,arg4,arg5); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ViewEdge *arg4 = (ViewEdge *) 0 ;
+  ChainPredicateIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "ViewEdge *""'"); 
+  }
+  arg4 = reinterpret_cast< ViewEdge * >(argp4);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,arg2,arg3,arg4); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(arg2,arg3,arg4); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  ChainPredicateIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,arg2,arg3); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(arg2,arg3); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  bool arg2 ;
+  ChainPredicateIterator *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainPredicateIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,arg2); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainPredicateIterator *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ChainPredicateIterator",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  BinaryPredicate1D *arg3 = 0 ;
+  bool arg4 ;
+  bool arg5 ;
+  ViewEdge *arg6 = (ViewEdge *) 0 ;
+  bool arg7 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  bool val7 ;
+  int ecode7 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< BinaryPredicate1D * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainPredicateIterator" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ChainPredicateIterator" "', argument " "6"" of type '" "ViewEdge *""'"); 
+  }
+  arg6 = reinterpret_cast< ViewEdge * >(argp6);
+  ecode7 = SWIG_AsVal_bool(obj6, &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ChainPredicateIterator" "', argument " "7"" of type '" "bool""'");
+  } 
+  arg7 = static_cast< bool >(val7);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,*arg2,*arg3,arg4,arg5,arg6,arg7); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(*arg2,*arg3,arg4,arg5,arg6,arg7); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  BinaryPredicate1D *arg3 = 0 ;
+  bool arg4 ;
+  bool arg5 ;
+  ViewEdge *arg6 = (ViewEdge *) 0 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< BinaryPredicate1D * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainPredicateIterator" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_ChainPredicateIterator" "', argument " "6"" of type '" "ViewEdge *""'"); 
+  }
+  arg6 = reinterpret_cast< ViewEdge * >(argp6);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,*arg2,*arg3,arg4,arg5,arg6); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(*arg2,*arg3,arg4,arg5,arg6); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  BinaryPredicate1D *arg3 = 0 ;
+  bool arg4 ;
+  bool arg5 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< BinaryPredicate1D * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ChainPredicateIterator" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,*arg2,*arg3,arg4,arg5); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(*arg2,*arg3,arg4,arg5); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  BinaryPredicate1D *arg3 = 0 ;
+  bool arg4 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< BinaryPredicate1D * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ChainPredicateIterator" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,*arg2,*arg3,arg4); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(*arg2,*arg3,arg4); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  BinaryPredicate1D *arg3 = 0 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ChainPredicateIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "3"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< BinaryPredicate1D * >(argp3);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,*arg2,*arg3); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator(*arg2,*arg3); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  ChainPredicateIterator *arg2 = 0 ;
+  ChainPredicateIterator *result = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ChainPredicateIterator",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_ChainPredicateIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "ChainPredicateIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ChainPredicateIterator" "', argument " "2"" of type '" "ChainPredicateIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< ChainPredicateIterator * >(argp2);
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (ChainPredicateIterator *)new SwigDirector_ChainPredicateIterator(arg1,(ChainPredicateIterator const &)*arg2); 
+      } else {
+        result = (ChainPredicateIterator *)new ChainPredicateIterator((ChainPredicateIterator const &)*arg2); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ChainPredicateIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[8];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 7); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_ChainPredicateIterator__SWIG_4(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_ChainPredicateIterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ChainPredicateIterator__SWIG_10(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ChainPredicateIterator__SWIG_3(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_BinaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_ChainPredicateIterator__SWIG_9(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ChainPredicateIterator__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_BinaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_ChainPredicateIterator__SWIG_8(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ViewEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_ChainPredicateIterator__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_BinaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_ChainPredicateIterator__SWIG_7(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ViewEdge, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_new_ChainPredicateIterator__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_BinaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_ViewEdge, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                return _wrap_new_ChainPredicateIterator__SWIG_6(self, args);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 7) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_BinaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_ViewEdge, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                {
+                  int res = SWIG_AsVal_bool(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  return _wrap_new_ChainPredicateIterator__SWIG_5(self, args);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ChainPredicateIterator'.\n  Possible C/C++ prototypes are:\n    ChainPredicateIterator(PyObject *,bool,bool,ViewEdge *,bool)\n    ChainPredicateIterator(PyObject *,bool,bool,ViewEdge *)\n    ChainPredicateIterator(PyObject *,bool,bool)\n    ChainPredicateIterator(PyObject *,bool)\n    ChainPredicateIterator(PyObject *)\n    ChainPredicateIterator(PyObject *,UnaryPredicate1D &,BinaryPredicate1D &,bool,bool,ViewEdge *,bool)\n    ChainPredicateIterator(PyObject *,UnaryPredicate1D &,BinaryPredicate1D &,bool,bool,ViewEdge *)\n    ChainPredicateIterator(PyObject *,UnaryPredicate1D &,BinaryPredicate1D &,bool,bool)\n    ChainPredicateIterator(PyObject *,UnaryPredicate1D &,BinaryPredicate1D &,bool)\n    ChainPredicateIterator(PyObject *,UnaryPredicate1D &,BinaryPredicate1D &)\n    ChainPredicateIterator(PyObject *,ChainPredicateIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ChainPredicateIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainPredicateIterator *arg1 = (ChainPredicateIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ChainPredicateIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainPredicateIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChainPredicateIterator" "', argument " "1"" of type '" "ChainPredicateIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainPredicateIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainPredicateIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainPredicateIterator *arg1 = (ChainPredicateIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ChainPredicateIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainPredicateIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainPredicateIterator_getExactTypeName" "', argument " "1"" of type '" "ChainPredicateIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainPredicateIterator * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((ChainPredicateIterator const *)arg1)->ChainPredicateIterator::getExactTypeName();
+        } else {
+          result = ((ChainPredicateIterator const *)arg1)->getExactTypeName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ChainPredicateIterator_traverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainPredicateIterator *arg1 = (ChainPredicateIterator *) 0 ;
+  AdjacencyIterator *arg2 = 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ChainPredicateIterator_traverse",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainPredicateIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChainPredicateIterator_traverse" "', argument " "1"" of type '" "ChainPredicateIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainPredicateIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_AdjacencyIterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChainPredicateIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ChainPredicateIterator_traverse" "', argument " "2"" of type '" "AdjacencyIterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< AdjacencyIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (ViewEdge *)(arg1)->ChainPredicateIterator::traverse((AdjacencyIterator const &)*arg2);
+        } else {
+          result = (ViewEdge *)(arg1)->traverse((AdjacencyIterator const &)*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_ChainPredicateIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainPredicateIterator *arg1 = (ChainPredicateIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_ChainPredicateIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ChainPredicateIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ChainPredicateIterator" "', argument " "1"" of type '" "ChainPredicateIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ChainPredicateIterator * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ChainPredicateIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ChainPredicateIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryPredicate0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate0D *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryPredicate0D",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryPredicate0D *)new SwigDirector_UnaryPredicate0D(arg1); 
+      } else {
+        result = (UnaryPredicate0D *)new UnaryPredicate0D(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryPredicate0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryPredicate0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = (UnaryPredicate0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryPredicate0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryPredicate0D" "', argument " "1"" of type '" "UnaryPredicate0D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryPredicate0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = (UnaryPredicate0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryPredicate0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryPredicate0D_getName" "', argument " "1"" of type '" "UnaryPredicate0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryPredicate0D const *)arg1)->UnaryPredicate0D::getName();
+        } else {
+          result = ((UnaryPredicate0D const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryPredicate0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = (UnaryPredicate0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryPredicate0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryPredicate0D___call__" "', argument " "1"" of type '" "UnaryPredicate0D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryPredicate0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryPredicate0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)(arg1)->UnaryPredicate0D::operator ()(*arg2);
+        } else {
+          result = (bool)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryPredicate0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = (UnaryPredicate0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryPredicate0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryPredicate0D" "', argument " "1"" of type '" "UnaryPredicate0D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryPredicate0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryPredicate0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_BinaryPredicate0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_BinaryPredicate0D")) SWIG_fail;
+  {
+    try {
+      result = (BinaryPredicate0D *)new BinaryPredicate0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BinaryPredicate0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_BinaryPredicate0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate0D *arg1 = (BinaryPredicate0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_BinaryPredicate0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinaryPredicate0D" "', argument " "1"" of type '" "BinaryPredicate0D *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BinaryPredicate0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate0D *arg1 = (BinaryPredicate0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:BinaryPredicate0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryPredicate0D_getName" "', argument " "1"" of type '" "BinaryPredicate0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate0D * >(argp1);
+  {
+    try {
+      result = ((BinaryPredicate0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BinaryPredicate0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate0D *arg1 = (BinaryPredicate0D *) 0 ;
+  Interface0D *arg2 = 0 ;
+  Interface0D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:BinaryPredicate0D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryPredicate0D___call__" "', argument " "1"" of type '" "BinaryPredicate0D *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BinaryPredicate0D___call__" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryPredicate0D___call__" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BinaryPredicate0D___call__" "', argument " "3"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryPredicate0D___call__" "', argument " "3"" of type '" "Interface0D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface0D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *BinaryPredicate0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_BinaryPredicate0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_TrueUP0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::TrueUP0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_TrueUP0D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates0D::TrueUP0D *)new Predicates0D::TrueUP0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates0D__TrueUP0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TrueUP0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::TrueUP0D *arg1 = (Predicates0D::TrueUP0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TrueUP0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__TrueUP0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueUP0D_getName" "', argument " "1"" of type '" "Predicates0D::TrueUP0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::TrueUP0D * >(argp1);
+  {
+    try {
+      result = ((Predicates0D::TrueUP0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TrueUP0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::TrueUP0D *arg1 = (Predicates0D::TrueUP0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TrueUP0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__TrueUP0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueUP0D___call__" "', argument " "1"" of type '" "Predicates0D::TrueUP0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::TrueUP0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TrueUP0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TrueUP0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TrueUP0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::TrueUP0D *arg1 = (Predicates0D::TrueUP0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrueUP0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__TrueUP0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrueUP0D" "', argument " "1"" of type '" "Predicates0D::TrueUP0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::TrueUP0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TrueUP0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates0D__TrueUP0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_FalseUP0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::FalseUP0D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FalseUP0D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates0D::FalseUP0D *)new Predicates0D::FalseUP0D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates0D__FalseUP0D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FalseUP0D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::FalseUP0D *arg1 = (Predicates0D::FalseUP0D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FalseUP0D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__FalseUP0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseUP0D_getName" "', argument " "1"" of type '" "Predicates0D::FalseUP0D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::FalseUP0D * >(argp1);
+  {
+    try {
+      result = ((Predicates0D::FalseUP0D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FalseUP0D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::FalseUP0D *arg1 = (Predicates0D::FalseUP0D *) 0 ;
+  Interface0DIterator *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FalseUP0D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__FalseUP0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseUP0D___call__" "', argument " "1"" of type '" "Predicates0D::FalseUP0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::FalseUP0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIterator,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FalseUP0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FalseUP0D___call__" "', argument " "2"" of type '" "Interface0DIterator &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIterator * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FalseUP0D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates0D::FalseUP0D *arg1 = (Predicates0D::FalseUP0D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FalseUP0D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates0D__FalseUP0D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FalseUP0D" "', argument " "1"" of type '" "Predicates0D::FalseUP0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates0D::FalseUP0D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FalseUP0D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates0D__FalseUP0D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UnaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  UnaryPredicate1D *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UnaryPredicate1D",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (UnaryPredicate1D *)new SwigDirector_UnaryPredicate1D(arg1); 
+      } else {
+        result = (UnaryPredicate1D *)new UnaryPredicate1D(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UnaryPredicate1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UnaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = (UnaryPredicate1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnaryPredicate1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnaryPredicate1D" "', argument " "1"" of type '" "UnaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryPredicate1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = (UnaryPredicate1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:UnaryPredicate1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryPredicate1D_getName" "', argument " "1"" of type '" "UnaryPredicate1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((UnaryPredicate1D const *)arg1)->UnaryPredicate1D::getName();
+        } else {
+          result = ((UnaryPredicate1D const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UnaryPredicate1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = (UnaryPredicate1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:UnaryPredicate1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnaryPredicate1D___call__" "', argument " "1"" of type '" "UnaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnaryPredicate1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UnaryPredicate1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)(arg1)->UnaryPredicate1D::operator ()(*arg2);
+        } else {
+          result = (bool)(arg1)->operator ()(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_UnaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = (UnaryPredicate1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_UnaryPredicate1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UnaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UnaryPredicate1D" "', argument " "1"" of type '" "UnaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UnaryPredicate1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UnaryPredicate1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_BinaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  BinaryPredicate1D *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_BinaryPredicate1D",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (BinaryPredicate1D *)new SwigDirector_BinaryPredicate1D(arg1); 
+      } else {
+        result = (BinaryPredicate1D *)new BinaryPredicate1D(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BinaryPredicate1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_BinaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate1D *arg1 = (BinaryPredicate1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_BinaryPredicate1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinaryPredicate1D" "', argument " "1"" of type '" "BinaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BinaryPredicate1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate1D *arg1 = (BinaryPredicate1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:BinaryPredicate1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryPredicate1D_getName" "', argument " "1"" of type '" "BinaryPredicate1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate1D * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((BinaryPredicate1D const *)arg1)->BinaryPredicate1D::getName();
+        } else {
+          result = ((BinaryPredicate1D const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BinaryPredicate1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate1D *arg1 = (BinaryPredicate1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:BinaryPredicate1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryPredicate1D___call__" "', argument " "1"" of type '" "BinaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BinaryPredicate1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryPredicate1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BinaryPredicate1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryPredicate1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)(arg1)->BinaryPredicate1D::operator ()(*arg2,*arg3);
+        } else {
+          result = (bool)(arg1)->operator ()(*arg2,*arg3);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_BinaryPredicate1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate1D *arg1 = (BinaryPredicate1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_BinaryPredicate1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_BinaryPredicate1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BinaryPredicate1D" "', argument " "1"" of type '" "BinaryPredicate1D *""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate1D * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *BinaryPredicate1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_BinaryPredicate1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_TrueUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueUP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_TrueUP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::TrueUP1D *)new Predicates1D::TrueUP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__TrueUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TrueUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueUP1D *arg1 = (Predicates1D::TrueUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TrueUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueUP1D_getName" "', argument " "1"" of type '" "Predicates1D::TrueUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::TrueUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TrueUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueUP1D *arg1 = (Predicates1D::TrueUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TrueUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueUP1D___call__" "', argument " "1"" of type '" "Predicates1D::TrueUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TrueUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TrueUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TrueUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueUP1D *arg1 = (Predicates1D::TrueUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrueUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrueUP1D" "', argument " "1"" of type '" "Predicates1D::TrueUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TrueUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__TrueUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_FalseUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseUP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FalseUP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::FalseUP1D *)new Predicates1D::FalseUP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__FalseUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FalseUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseUP1D *arg1 = (Predicates1D::FalseUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FalseUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseUP1D_getName" "', argument " "1"" of type '" "Predicates1D::FalseUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::FalseUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FalseUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseUP1D *arg1 = (Predicates1D::FalseUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FalseUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseUP1D___call__" "', argument " "1"" of type '" "Predicates1D::FalseUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FalseUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FalseUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FalseUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseUP1D *arg1 = (Predicates1D::FalseUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FalseUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FalseUP1D" "', argument " "1"" of type '" "Predicates1D::FalseUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FalseUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__FalseUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityUP1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Predicates1D::QuantitativeInvisibilityUP1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_QuantitativeInvisibilityUP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuantitativeInvisibilityUP1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Predicates1D::QuantitativeInvisibilityUP1D *)new Predicates1D::QuantitativeInvisibilityUP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityUP1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::QuantitativeInvisibilityUP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_QuantitativeInvisibilityUP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::QuantitativeInvisibilityUP1D *)new Predicates1D::QuantitativeInvisibilityUP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_QuantitativeInvisibilityUP1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_QuantitativeInvisibilityUP1D__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_QuantitativeInvisibilityUP1D__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_QuantitativeInvisibilityUP1D'.\n  Possible C/C++ prototypes are:\n    Predicates1D::QuantitativeInvisibilityUP1D(unsigned int)\n    Predicates1D::QuantitativeInvisibilityUP1D()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::QuantitativeInvisibilityUP1D *arg1 = (Predicates1D::QuantitativeInvisibilityUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:QuantitativeInvisibilityUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityUP1D_getName" "', argument " "1"" of type '" "Predicates1D::QuantitativeInvisibilityUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::QuantitativeInvisibilityUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::QuantitativeInvisibilityUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_QuantitativeInvisibilityUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::QuantitativeInvisibilityUP1D *arg1 = (Predicates1D::QuantitativeInvisibilityUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:QuantitativeInvisibilityUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuantitativeInvisibilityUP1D___call__" "', argument " "1"" of type '" "Predicates1D::QuantitativeInvisibilityUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::QuantitativeInvisibilityUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuantitativeInvisibilityUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuantitativeInvisibilityUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_QuantitativeInvisibilityUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::QuantitativeInvisibilityUP1D *arg1 = (Predicates1D::QuantitativeInvisibilityUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuantitativeInvisibilityUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantitativeInvisibilityUP1D" "', argument " "1"" of type '" "Predicates1D::QuantitativeInvisibilityUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::QuantitativeInvisibilityUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *QuantitativeInvisibilityUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__QuantitativeInvisibilityUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ContourUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ContourUP1D *arg1 = (Predicates1D::ContourUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ContourUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ContourUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContourUP1D_getName" "', argument " "1"" of type '" "Predicates1D::ContourUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ContourUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::ContourUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ContourUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ContourUP1D *arg1 = (Predicates1D::ContourUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ContourUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ContourUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContourUP1D___call__" "', argument " "1"" of type '" "Predicates1D::ContourUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ContourUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContourUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ContourUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ContourUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ContourUP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ContourUP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::ContourUP1D *)new Predicates1D::ContourUP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ContourUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ContourUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ContourUP1D *arg1 = (Predicates1D::ContourUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContourUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ContourUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContourUP1D" "', argument " "1"" of type '" "Predicates1D::ContourUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ContourUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ContourUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__ContourUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ExternalContourUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ExternalContourUP1D *arg1 = (Predicates1D::ExternalContourUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ExternalContourUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ExternalContourUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalContourUP1D_getName" "', argument " "1"" of type '" "Predicates1D::ExternalContourUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ExternalContourUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::ExternalContourUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ExternalContourUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ExternalContourUP1D *arg1 = (Predicates1D::ExternalContourUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ExternalContourUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ExternalContourUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalContourUP1D___call__" "', argument " "1"" of type '" "Predicates1D::ExternalContourUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ExternalContourUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExternalContourUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExternalContourUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ExternalContourUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ExternalContourUP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ExternalContourUP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::ExternalContourUP1D *)new Predicates1D::ExternalContourUP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ExternalContourUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ExternalContourUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ExternalContourUP1D *arg1 = (Predicates1D::ExternalContourUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExternalContourUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ExternalContourUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExternalContourUP1D" "', argument " "1"" of type '" "Predicates1D::ExternalContourUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ExternalContourUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ExternalContourUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__ExternalContourUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_EqualToTimeStampUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Predicates1D::EqualToTimeStampUP1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_EqualToTimeStampUP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EqualToTimeStampUP1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Predicates1D::EqualToTimeStampUP1D *)new Predicates1D::EqualToTimeStampUP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_EqualToTimeStampUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToTimeStampUP1D *arg1 = (Predicates1D::EqualToTimeStampUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:EqualToTimeStampUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EqualToTimeStampUP1D_getName" "', argument " "1"" of type '" "Predicates1D::EqualToTimeStampUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToTimeStampUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::EqualToTimeStampUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_EqualToTimeStampUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToTimeStampUP1D *arg1 = (Predicates1D::EqualToTimeStampUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:EqualToTimeStampUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EqualToTimeStampUP1D___call__" "', argument " "1"" of type '" "Predicates1D::EqualToTimeStampUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToTimeStampUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EqualToTimeStampUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EqualToTimeStampUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_EqualToTimeStampUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToTimeStampUP1D *arg1 = (Predicates1D::EqualToTimeStampUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_EqualToTimeStampUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EqualToTimeStampUP1D" "', argument " "1"" of type '" "Predicates1D::EqualToTimeStampUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToTimeStampUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *EqualToTimeStampUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__EqualToTimeStampUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_EqualToChainingTimeStampUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Predicates1D::EqualToChainingTimeStampUP1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_EqualToChainingTimeStampUP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EqualToChainingTimeStampUP1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Predicates1D::EqualToChainingTimeStampUP1D *)new Predicates1D::EqualToChainingTimeStampUP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_EqualToChainingTimeStampUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToChainingTimeStampUP1D *arg1 = (Predicates1D::EqualToChainingTimeStampUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:EqualToChainingTimeStampUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EqualToChainingTimeStampUP1D_getName" "', argument " "1"" of type '" "Predicates1D::EqualToChainingTimeStampUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToChainingTimeStampUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::EqualToChainingTimeStampUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_EqualToChainingTimeStampUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToChainingTimeStampUP1D *arg1 = (Predicates1D::EqualToChainingTimeStampUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:EqualToChainingTimeStampUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EqualToChainingTimeStampUP1D___call__" "', argument " "1"" of type '" "Predicates1D::EqualToChainingTimeStampUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToChainingTimeStampUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EqualToChainingTimeStampUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EqualToChainingTimeStampUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_EqualToChainingTimeStampUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::EqualToChainingTimeStampUP1D *arg1 = (Predicates1D::EqualToChainingTimeStampUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_EqualToChainingTimeStampUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EqualToChainingTimeStampUP1D" "', argument " "1"" of type '" "Predicates1D::EqualToChainingTimeStampUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::EqualToChainingTimeStampUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *EqualToChainingTimeStampUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__EqualToChainingTimeStampUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ShapeUP1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  unsigned int arg2 ;
+  Predicates1D::ShapeUP1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ShapeUP1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShapeUP1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShapeUP1D" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      result = (Predicates1D::ShapeUP1D *)new Predicates1D::ShapeUP1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ShapeUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShapeUP1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Predicates1D::ShapeUP1D *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ShapeUP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShapeUP1D" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Predicates1D::ShapeUP1D *)new Predicates1D::ShapeUP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ShapeUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShapeUP1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ShapeUP1D__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ShapeUP1D__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ShapeUP1D'.\n  Possible C/C++ prototypes are:\n    Predicates1D::ShapeUP1D(unsigned int,unsigned int)\n    Predicates1D::ShapeUP1D(unsigned int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShapeUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ShapeUP1D *arg1 = (Predicates1D::ShapeUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShapeUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ShapeUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShapeUP1D_getName" "', argument " "1"" of type '" "Predicates1D::ShapeUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ShapeUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::ShapeUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShapeUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ShapeUP1D *arg1 = (Predicates1D::ShapeUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShapeUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ShapeUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShapeUP1D___call__" "', argument " "1"" of type '" "Predicates1D::ShapeUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ShapeUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShapeUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShapeUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ShapeUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ShapeUP1D *arg1 = (Predicates1D::ShapeUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ShapeUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ShapeUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShapeUP1D" "', argument " "1"" of type '" "Predicates1D::ShapeUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ShapeUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ShapeUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__ShapeUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_TrueBP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueBP1D *arg1 = (Predicates1D::TrueBP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:TrueBP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueBP1D_getName" "', argument " "1"" of type '" "Predicates1D::TrueBP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueBP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::TrueBP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TrueBP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueBP1D *arg1 = (Predicates1D::TrueBP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:TrueBP1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrueBP1D___call__" "', argument " "1"" of type '" "Predicates1D::TrueBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueBP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TrueBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TrueBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TrueBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TrueBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_TrueBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueBP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_TrueBP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::TrueBP1D *)new Predicates1D::TrueBP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__TrueBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TrueBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::TrueBP1D *arg1 = (Predicates1D::TrueBP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrueBP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__TrueBP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrueBP1D" "', argument " "1"" of type '" "Predicates1D::TrueBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::TrueBP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TrueBP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__TrueBP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_FalseBP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseBP1D *arg1 = (Predicates1D::FalseBP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FalseBP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseBP1D_getName" "', argument " "1"" of type '" "Predicates1D::FalseBP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseBP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::FalseBP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FalseBP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseBP1D *arg1 = (Predicates1D::FalseBP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FalseBP1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FalseBP1D___call__" "', argument " "1"" of type '" "Predicates1D::FalseBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseBP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FalseBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FalseBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FalseBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FalseBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FalseBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseBP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_FalseBP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::FalseBP1D *)new Predicates1D::FalseBP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__FalseBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FalseBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::FalseBP1D *arg1 = (Predicates1D::FalseBP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FalseBP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__FalseBP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FalseBP1D" "', argument " "1"" of type '" "Predicates1D::FalseBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::FalseBP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FalseBP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__FalseBP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Length2DBP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::Length2DBP1D *arg1 = (Predicates1D::Length2DBP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Length2DBP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__Length2DBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Length2DBP1D_getName" "', argument " "1"" of type '" "Predicates1D::Length2DBP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::Length2DBP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::Length2DBP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Length2DBP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::Length2DBP1D *arg1 = (Predicates1D::Length2DBP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Length2DBP1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__Length2DBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Length2DBP1D___call__" "', argument " "1"" of type '" "Predicates1D::Length2DBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::Length2DBP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Length2DBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Length2DBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Length2DBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Length2DBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Length2DBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::Length2DBP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Length2DBP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::Length2DBP1D *)new Predicates1D::Length2DBP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__Length2DBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Length2DBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::Length2DBP1D *arg1 = (Predicates1D::Length2DBP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Length2DBP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__Length2DBP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Length2DBP1D" "', argument " "1"" of type '" "Predicates1D::Length2DBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::Length2DBP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Length2DBP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__Length2DBP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_SameShapeIdBP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::SameShapeIdBP1D *arg1 = (Predicates1D::SameShapeIdBP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:SameShapeIdBP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__SameShapeIdBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SameShapeIdBP1D_getName" "', argument " "1"" of type '" "Predicates1D::SameShapeIdBP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::SameShapeIdBP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::SameShapeIdBP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SameShapeIdBP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::SameShapeIdBP1D *arg1 = (Predicates1D::SameShapeIdBP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:SameShapeIdBP1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__SameShapeIdBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SameShapeIdBP1D___call__" "', argument " "1"" of type '" "Predicates1D::SameShapeIdBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::SameShapeIdBP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SameShapeIdBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SameShapeIdBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SameShapeIdBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SameShapeIdBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_SameShapeIdBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::SameShapeIdBP1D *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_SameShapeIdBP1D")) SWIG_fail;
+  {
+    try {
+      result = (Predicates1D::SameShapeIdBP1D *)new Predicates1D::SameShapeIdBP1D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__SameShapeIdBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SameShapeIdBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::SameShapeIdBP1D *arg1 = (Predicates1D::SameShapeIdBP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SameShapeIdBP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__SameShapeIdBP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SameShapeIdBP1D" "', argument " "1"" of type '" "Predicates1D::SameShapeIdBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::SameShapeIdBP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SameShapeIdBP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__SameShapeIdBP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ViewMapGradientNormBP1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  float arg3 ;
+  Predicates1D::ViewMapGradientNormBP1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ViewMapGradientNormBP1D",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (Predicates1D::ViewMapGradientNormBP1D *)new Predicates1D::ViewMapGradientNormBP1D(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewMapGradientNormBP1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  IntegrationType arg2 ;
+  Predicates1D::ViewMapGradientNormBP1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ViewMapGradientNormBP1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "2"" of type '" "IntegrationType""'");
+  } 
+  arg2 = static_cast< IntegrationType >(val2);
+  {
+    try {
+      result = (Predicates1D::ViewMapGradientNormBP1D *)new Predicates1D::ViewMapGradientNormBP1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewMapGradientNormBP1D__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  Predicates1D::ViewMapGradientNormBP1D *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ViewMapGradientNormBP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ViewMapGradientNormBP1D" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (Predicates1D::ViewMapGradientNormBP1D *)new Predicates1D::ViewMapGradientNormBP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ViewMapGradientNormBP1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ViewMapGradientNormBP1D__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ViewMapGradientNormBP1D__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ViewMapGradientNormBP1D__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ViewMapGradientNormBP1D'.\n  Possible C/C++ prototypes are:\n    Predicates1D::ViewMapGradientNormBP1D(int,IntegrationType,float)\n    Predicates1D::ViewMapGradientNormBP1D(int,IntegrationType)\n    Predicates1D::ViewMapGradientNormBP1D(int)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMapGradientNormBP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ViewMapGradientNormBP1D *arg1 = (Predicates1D::ViewMapGradientNormBP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ViewMapGradientNormBP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMapGradientNormBP1D_getName" "', argument " "1"" of type '" "Predicates1D::ViewMapGradientNormBP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ViewMapGradientNormBP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::ViewMapGradientNormBP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ViewMapGradientNormBP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ViewMapGradientNormBP1D *arg1 = (Predicates1D::ViewMapGradientNormBP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  Interface1D *arg3 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ViewMapGradientNormBP1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ViewMapGradientNormBP1D___call__" "', argument " "1"" of type '" "Predicates1D::ViewMapGradientNormBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ViewMapGradientNormBP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ViewMapGradientNormBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMapGradientNormBP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ViewMapGradientNormBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ViewMapGradientNormBP1D___call__" "', argument " "3"" of type '" "Interface1D &""'"); 
+  }
+  arg3 = reinterpret_cast< Interface1D * >(argp3);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ViewMapGradientNormBP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::ViewMapGradientNormBP1D *arg1 = (Predicates1D::ViewMapGradientNormBP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ViewMapGradientNormBP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ViewMapGradientNormBP1D" "', argument " "1"" of type '" "Predicates1D::ViewMapGradientNormBP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::ViewMapGradientNormBP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ViewMapGradientNormBP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__ViewMapGradientNormBP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_DensityLowerThanUP1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  double arg2 ;
+  Predicates1D::DensityLowerThanUP1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityLowerThanUP1D",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityLowerThanUP1D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityLowerThanUP1D" "', argument " "2"" of type '" "double""'");
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    try {
+      result = (Predicates1D::DensityLowerThanUP1D *)new Predicates1D::DensityLowerThanUP1D(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityLowerThanUP1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  double arg1 ;
+  Predicates1D::DensityLowerThanUP1D *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_DensityLowerThanUP1D",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DensityLowerThanUP1D" "', argument " "1"" of type '" "double""'");
+  } 
+  arg1 = static_cast< double >(val1);
+  {
+    try {
+      result = (Predicates1D::DensityLowerThanUP1D *)new Predicates1D::DensityLowerThanUP1D(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_DensityLowerThanUP1D(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_DensityLowerThanUP1D__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_DensityLowerThanUP1D__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_DensityLowerThanUP1D'.\n  Possible C/C++ prototypes are:\n    Predicates1D::DensityLowerThanUP1D(double,double)\n    Predicates1D::DensityLowerThanUP1D(double)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityLowerThanUP1D_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::DensityLowerThanUP1D *arg1 = (Predicates1D::DensityLowerThanUP1D *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:DensityLowerThanUP1D_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityLowerThanUP1D_getName" "', argument " "1"" of type '" "Predicates1D::DensityLowerThanUP1D const *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::DensityLowerThanUP1D * >(argp1);
+  {
+    try {
+      result = ((Predicates1D::DensityLowerThanUP1D const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_DensityLowerThanUP1D___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::DensityLowerThanUP1D *arg1 = (Predicates1D::DensityLowerThanUP1D *) 0 ;
+  Interface1D *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:DensityLowerThanUP1D___call__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityLowerThanUP1D___call__" "', argument " "1"" of type '" "Predicates1D::DensityLowerThanUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::DensityLowerThanUP1D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityLowerThanUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DensityLowerThanUP1D___call__" "', argument " "2"" of type '" "Interface1D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface1D * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ()(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_DensityLowerThanUP1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Predicates1D::DensityLowerThanUP1D *arg1 = (Predicates1D::DensityLowerThanUP1D *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityLowerThanUP1D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityLowerThanUP1D" "', argument " "1"" of type '" "Predicates1D::DensityLowerThanUP1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Predicates1D::DensityLowerThanUP1D * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *DensityLowerThanUP1D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Predicates1D__DensityLowerThanUP1D, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__CurvilinearLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__CurvilinearLength_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__CurvilinearLength_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__CurvilinearLength_set" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  if (arg1) (arg1)->_CurvilinearLength = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__CurvilinearLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__CurvilinearLength_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__CurvilinearLength_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (float) ((arg1)->_CurvilinearLength);
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__step_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__step_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__step_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__step_set" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  if (arg1) (arg1)->_step = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__step_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__step_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__step_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (float) ((arg1)->_step);
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___A_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator___A_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___A_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Curve__vertex_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator___A_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator___A_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'");
+    } else {
+      ::Curve::vertex_container::iterator * temp = reinterpret_cast< ::Curve::vertex_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  if (arg1) (arg1)->__A = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___A_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator___A_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___A_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result =  ((arg1)->__A);
+  resultobj = SWIG_NewPointerObj((new ::Curve::vertex_container::iterator(static_cast< const ::Curve::vertex_container::iterator& >(result))), SWIGTYPE_p_Curve__vertex_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___B_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator___B_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___B_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Curve__vertex_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator___B_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator___B_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'");
+    } else {
+      ::Curve::vertex_container::iterator * temp = reinterpret_cast< ::Curve::vertex_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  if (arg1) (arg1)->__B = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___B_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator___B_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___B_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result =  ((arg1)->__B);
+  resultobj = SWIG_NewPointerObj((new ::Curve::vertex_container::iterator(static_cast< const ::Curve::vertex_container::iterator& >(result))), SWIGTYPE_p_Curve__vertex_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__begin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__begin_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__begin_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Curve__vertex_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator__begin_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator__begin_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'");
+    } else {
+      ::Curve::vertex_container::iterator * temp = reinterpret_cast< ::Curve::vertex_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  if (arg1) (arg1)->_begin = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__begin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__begin_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__begin_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result =  ((arg1)->_begin);
+  resultobj = SWIG_NewPointerObj((new ::Curve::vertex_container::iterator(static_cast< const ::Curve::vertex_container::iterator& >(result))), SWIGTYPE_p_Curve__vertex_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__end_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__end_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__end_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Curve__vertex_container__iterator,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator__end_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'"); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator__end_set" "', argument " "2"" of type '" "::Curve::vertex_container::iterator""'");
+    } else {
+      ::Curve::vertex_container::iterator * temp = reinterpret_cast< ::Curve::vertex_container::iterator * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  if (arg1) (arg1)->_end = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__end_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ::Curve::vertex_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__end_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__end_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result =  ((arg1)->_end);
+  resultobj = SWIG_NewPointerObj((new ::Curve::vertex_container::iterator(static_cast< const ::Curve::vertex_container::iterator& >(result))), SWIGTYPE_p_Curve__vertex_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__n_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__n_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__n_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__n_set" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  if (arg1) (arg1)->_n = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__n_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__n_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__n_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (int) ((arg1)->_n);
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__currentn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__currentn_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__currentn_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__currentn_set" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  if (arg1) (arg1)->_currentn = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__currentn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__currentn_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__currentn_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (int) ((arg1)->_currentn);
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__t_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__t_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__t_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__t_set" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  if (arg1) (arg1)->_t = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__t_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__t_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__t_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (float) ((arg1)->_t);
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__Point_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  CurvePoint *arg2 = (CurvePoint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__Point_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__Point_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator__Point_set" "', argument " "2"" of type '" "CurvePoint *""'"); 
+  }
+  arg2 = reinterpret_cast< CurvePoint * >(argp2);
+  if (arg1) (arg1)->_Point = *arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__Point_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__Point_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__Point_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (CurvePoint *)& ((arg1)->_Point);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__CurveLength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator__CurveLength_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__CurveLength_set" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator__CurveLength_set" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  if (arg1) (arg1)->_CurveLength = arg2;
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator__CurveLength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator__CurveLength_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator__CurveLength_get" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  result = (float) ((arg1)->_CurveLength);
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePointIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  CurveInternal::CurvePointIterator *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_CurvePointIterator",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CurvePointIterator" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (CurveInternal::CurvePointIterator *)new CurveInternal::CurvePointIterator(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePointIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_CurvePointIterator")) SWIG_fail;
+  {
+    try {
+      result = (CurveInternal::CurvePointIterator *)new CurveInternal::CurvePointIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePointIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = 0 ;
+  CurveInternal::CurvePointIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_CurvePointIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CurveInternal__CurvePointIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurvePointIterator" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurvePointIterator" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (CurveInternal::CurvePointIterator *)new CurveInternal::CurvePointIterator((CurveInternal::CurvePointIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePointIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_CurvePointIterator__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CurveInternal__CurvePointIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_CurvePointIterator__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_CurvePointIterator__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CurvePointIterator'.\n  Possible C/C++ prototypes are:\n    CurveInternal::CurvePointIterator(float)\n    CurveInternal::CurvePointIterator()\n    CurveInternal::CurvePointIterator(CurveInternal::CurvePointIterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CurvePointIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CurvePointIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurvePointIterator" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  CurveInternal::CurvePointIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_copy" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (CurveInternal::CurvePointIterator *)((CurveInternal::CurvePointIterator const *)arg1)->copy();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_CastToInterface0DIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_CastToInterface0DIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_CastToInterface0DIterator" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = ((CurveInternal::CurvePointIterator const *)arg1)->CastToInterface0DIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getExactTypeName" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = ((CurveInternal::CurvePointIterator const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___eq__" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((CurveInternal::CurvePointIterator const *)arg1)->operator ==((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getObject" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      {
+        CurvePoint &_result_ref = (arg1)->operator *();
+        result = (CurvePoint *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator___deref__" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (CurvePoint *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_isBegin" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (bool)((CurveInternal::CurvePointIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_isEnd" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (bool)((CurveInternal::CurvePointIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getX" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getY" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getZ" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getPoint3D" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getProjectedX" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getProjectedY" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getProjectedZ" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getPoint2D" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getFEdge" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePointIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getId" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_getNature" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_castToSVertex" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_castToViewVertex" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_castToNonTVertex" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_castToTVertex" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_A" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_B" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_t2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_t2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_t2d" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->t2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_setA" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator_setA" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_setB" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePointIterator_setB" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_setT2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePointIterator_setT2d",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_setT2d" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePointIterator_setT2d" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (*arg1)->setT2d(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_fedge" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_point2d" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_point3d" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_normal" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_shape" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occluders_begin" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occluders_end" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occluders_empty" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occluders_size" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occludee" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occluded_shape" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_occludee_empty" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_z_discontinuity" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_curvatureFredo" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePointIterator_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurveInternal::CurvePointIterator *arg1 = (CurveInternal::CurvePointIterator *) 0 ;
+  Geometry::Vec2d result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePointIterator_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurveInternal__CurvePointIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePointIterator_directionFredo" "', argument " "1"" of type '" "CurveInternal::CurvePointIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurveInternal::CurvePointIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2d(static_cast< const Geometry::Vec2d& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CurvePointIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getExactTypeName" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getX" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getY" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getZ" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getPoint3D" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getProjectedX" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getProjectedY" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getProjectedZ" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getPoint2D" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePoint_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getFEdge" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePoint_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePoint_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getId" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_getNature" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)((CurvePoint const *)arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_castToSVertex" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_castToViewVertex" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_castToNonTVertex" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_castToTVertex" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (TVertex *)(arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_CurvePoint")) SWIG_fail;
+  {
+    try {
+      result = (CurvePoint *)new CurvePoint();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  float arg3 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_CurvePoint",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurvePoint" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CurvePoint" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CurvePoint" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (CurvePoint *)new CurvePoint(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePoint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  CurvePoint *arg2 = (CurvePoint *) 0 ;
+  float arg3 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_CurvePoint",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurvePoint" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CurvePoint" "', argument " "2"" of type '" "CurvePoint *""'"); 
+  }
+  arg2 = reinterpret_cast< CurvePoint * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CurvePoint" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (CurvePoint *)new CurvePoint(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePoint__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = 0 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_CurvePoint",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_CurvePoint,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurvePoint" "', argument " "1"" of type '" "CurvePoint const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurvePoint" "', argument " "1"" of type '" "CurvePoint const &""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (CurvePoint *)new CurvePoint((CurvePoint const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_CurvePoint(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_CurvePoint__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_CurvePoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_CurvePoint__SWIG_3(self, args);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CurvePoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CurvePoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_CurvePoint__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_CurvePoint__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CurvePoint'.\n  Possible C/C++ prototypes are:\n    CurvePoint()\n    CurvePoint(SVertex *,SVertex *,float)\n    CurvePoint(CurvePoint *,CurvePoint *,float)\n    CurvePoint(CurvePoint const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CurvePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CurvePoint",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurvePoint" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  CurvePoint *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePoint___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint___eq__" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CurvePoint,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePoint___eq__" "', argument " "2"" of type '" "CurvePoint const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurvePoint___eq__" "', argument " "2"" of type '" "CurvePoint const &""'"); 
+  }
+  arg2 = reinterpret_cast< CurvePoint * >(argp2);
+  {
+    try {
+      result = (bool)(arg1)->operator ==((CurvePoint const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_A" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_B" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_t2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_t2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_t2d" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (float)((CurvePoint const *)arg1)->t2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePoint_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_setA" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePoint_setA" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePoint_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_setB" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurvePoint_setB" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_setT2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CurvePoint_setT2d",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_setT2d" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CurvePoint_setT2d" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setT2d(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_fedge" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_point2d" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((CurvePoint const *)arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_point3d" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = ((CurvePoint const *)arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_normal" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_shape" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (SShape *)((CurvePoint const *)arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occluders_begin" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occluders_end" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occluders_empty" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (bool)((CurvePoint const *)arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occluders_size" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (int)((CurvePoint const *)arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occludee" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = ((CurvePoint const *)arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occluded_shape" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (SShape *)((CurvePoint const *)arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_occludee_empty" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (bool)((CurvePoint const *)arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_z_discontinuity" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_curvatureFredo" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (real)((CurvePoint const *)arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CurvePoint_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  Geometry::Vec2d result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:CurvePoint_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurvePoint_directionFredo" "', argument " "1"" of type '" "CurvePoint const *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = ((CurvePoint const *)arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2d(static_cast< const Geometry::Vec2d& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CurvePoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_CurvePoint, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Curve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Curve")) SWIG_fail;
+  {
+    try {
+      result = (Curve *)new Curve();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Curve, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Id *arg1 = 0 ;
+  Curve *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Curve",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Curve" "', argument " "1"" of type '" "Id const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Curve" "', argument " "1"" of type '" "Id const &""'"); 
+  }
+  arg1 = reinterpret_cast< Id * >(argp1);
+  {
+    try {
+      result = (Curve *)new Curve((Id const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Curve, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curve__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = 0 ;
+  Curve *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Curve",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Curve,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Curve" "', argument " "1"" of type '" "Curve const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Curve" "', argument " "1"" of type '" "Curve const &""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (Curve *)new Curve((Curve const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Curve, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Curve(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Curve__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Id, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Curve__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Curve__SWIG_2(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Curve'.\n  Possible C/C++ prototypes are:\n    Curve()\n    Curve(Id const &)\n    Curve(Curve const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Curve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Curve",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Curve" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_computeCurvatureAndOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_computeCurvatureAndOrientation",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_computeCurvatureAndOrientation" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      (arg1)->computeCurvatureAndOrientation();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_back__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Curve::Vertex *arg2 = (Curve::Vertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_push_vertex_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_push_vertex_back" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curve_push_vertex_back" "', argument " "2"" of type '" "Curve::Vertex *""'"); 
+  }
+  arg2 = reinterpret_cast< Curve::Vertex * >(argp2);
+  {
+    try {
+      (arg1)->push_vertex_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_back__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_push_vertex_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_push_vertex_back" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curve_push_vertex_back" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->push_vertex_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_back(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CurvePoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Curve_push_vertex_back__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Curve_push_vertex_back__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_push_vertex_back'.\n  Possible C/C++ prototypes are:\n    push_vertex_back(Curve::Vertex *)\n    push_vertex_back(SVertex *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_front__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Curve::Vertex *arg2 = (Curve::Vertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_push_vertex_front",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_push_vertex_front" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curve_push_vertex_front" "', argument " "2"" of type '" "Curve::Vertex *""'"); 
+  }
+  arg2 = reinterpret_cast< Curve::Vertex * >(argp2);
+  {
+    try {
+      (arg1)->push_vertex_front(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_front__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_push_vertex_front",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_push_vertex_front" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curve_push_vertex_front" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (arg1)->push_vertex_front(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_push_vertex_front(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CurvePoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Curve_push_vertex_front__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_SVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Curve_push_vertex_front__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_push_vertex_front'.\n  Possible C/C++ prototypes are:\n    push_vertex_front(Curve::Vertex *)\n    push_vertex_front(SVertex *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_empty" "', argument " "1"" of type '" "Curve const *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (bool)((Curve const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_getLength2D" "', argument " "1"" of type '" "Curve const *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (real)((Curve const *)arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_getId" "', argument " "1"" of type '" "Curve const *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = ((Curve const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_nSegments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_nSegments",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_nSegments" "', argument " "1"" of type '" "Curve const *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (unsigned int)((Curve const *)arg1)->nSegments();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_setId" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Curve_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Curve_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  float arg2 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_curvePointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curvePointsBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Curve_curvePointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->curvePointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_curvePointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curvePointsBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->curvePointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Curve_curvePointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Curve_curvePointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_curvePointsBegin'.\n  Possible C/C++ prototypes are:\n    curvePointsBegin(float)\n    curvePointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  float arg2 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_curvePointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curvePointsEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Curve_curvePointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->curvePointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_curvePointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curvePointsEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->curvePointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curvePointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Curve_curvePointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Curve_curvePointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_curvePointsEnd'.\n  Possible C/C++ prototypes are:\n    curvePointsEnd(float)\n    curvePointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curveVerticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_curveVerticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curveVerticesBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->curveVerticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_curveVerticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  CurveInternal::CurvePointIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_curveVerticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_curveVerticesEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->curveVerticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new CurveInternal::CurvePointIterator(static_cast< const CurveInternal::CurvePointIterator& >(result))), SWIGTYPE_p_CurveInternal__CurvePointIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_verticesBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_verticesEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_pointsBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Curve_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_pointsBegin" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Curve_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Curve_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Curve_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_pointsEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Curve_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Curve *arg1 = (Curve *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Curve_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Curve, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Curve_pointsEnd" "', argument " "1"" of type '" "Curve *""'"); 
+  }
+  arg1 = reinterpret_cast< Curve * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Curve_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Curve_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Curve, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Curve_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Curve_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Curve_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Curve, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertexIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_StrokeVertexIterator")) SWIG_fail;
+  {
+    try {
+      result = (StrokeInternal::StrokeVertexIterator *)new StrokeInternal::StrokeVertexIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertexIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = 0 ;
+  StrokeInternal::StrokeVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertexIterator" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertexIterator" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (StrokeInternal::StrokeVertexIterator *)new StrokeInternal::StrokeVertexIterator((StrokeInternal::StrokeVertexIterator const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertexIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke::vertex_container::iterator *arg1 = 0 ;
+  Stroke::vertex_container::iterator *arg2 = 0 ;
+  Stroke::vertex_container::iterator *arg3 = 0 ;
+  StrokeInternal::StrokeVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_StrokeVertexIterator",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Stroke__vertex_container__iterator,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertexIterator" "', argument " "1"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertexIterator" "', argument " "1"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke::vertex_container::iterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke__vertex_container__iterator,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StrokeVertexIterator" "', argument " "2"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertexIterator" "', argument " "2"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke::vertex_container::iterator * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Stroke__vertex_container__iterator,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_StrokeVertexIterator" "', argument " "3"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertexIterator" "', argument " "3"" of type '" "Stroke::vertex_container::iterator const &""'"); 
+  }
+  arg3 = reinterpret_cast< Stroke::vertex_container::iterator * >(argp3);
+  {
+    try {
+      result = (StrokeInternal::StrokeVertexIterator *)new StrokeInternal::StrokeVertexIterator((Stroke::vertex_container::iterator const &)*arg1,(Stroke::vertex_container::iterator const &)*arg2,(Stroke::vertex_container::iterator const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertexIterator(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_StrokeVertexIterator__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeVertexIterator__SWIG_1(self, args);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Stroke__vertex_container__iterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Stroke__vertex_container__iterator, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Stroke__vertex_container__iterator, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_StrokeVertexIterator__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrokeVertexIterator'.\n  Possible C/C++ prototypes are:\n    StrokeInternal::StrokeVertexIterator()\n    StrokeInternal::StrokeVertexIterator(StrokeInternal::StrokeVertexIterator const &)\n    StrokeInternal::StrokeVertexIterator(Stroke::vertex_container::iterator const &,Stroke::vertex_container::iterator const &,Stroke::vertex_container::iterator const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_StrokeVertexIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrokeVertexIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrokeVertexIterator" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_castToInterface0DIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_castToInterface0DIterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_castToInterface0DIterator" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = ((StrokeInternal::StrokeVertexIterator const *)arg1)->castToInterface0DIterator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getExactTypeName" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = ((StrokeInternal::StrokeVertexIterator const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getObject",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getObject" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        StrokeVertex &_result_ref = (arg1)->operator *();
+        result = (StrokeVertex *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator___deref__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator___deref__" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (StrokeVertex *)(arg1)->operator ->();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_increment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_increment",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_increment" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->increment();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_decrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_decrement",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_decrement" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      (arg1)->decrement();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_isBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_isBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_isBegin" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((StrokeInternal::StrokeVertexIterator const *)arg1)->isBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_isEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_isEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_isEnd" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)((StrokeInternal::StrokeVertexIterator const *)arg1)->isEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Interface0DIteratorNested *arg2 = 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator___eq__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator___eq__" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0DIteratorNested,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertexIterator___eq__" "', argument " "2"" of type '" "Interface0DIteratorNested const &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0DIteratorNested * >(argp2);
+  {
+    try {
+      result = (bool)((StrokeInternal::StrokeVertexIterator const *)arg1)->operator ==((Interface0DIteratorNested const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_t",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_t" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((StrokeInternal::StrokeVertexIterator const *)arg1)->t();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_u" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)((StrokeInternal::StrokeVertexIterator const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeInternal::StrokeVertexIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_copy",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_copy" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (StrokeInternal::StrokeVertexIterator *)((StrokeInternal::StrokeVertexIterator const *)arg1)->copy();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getIt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Stroke::vertex_container::iterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getIt",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getIt" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Stroke::vertex_container::iterator const &_result_ref = (arg1)->getIt();
+        result = (Stroke::vertex_container::iterator *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Stroke__vertex_container__iterator, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_x" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_y" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getPoint",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getPoint" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_attribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_attribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_attribute" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        StrokeAttribute const &_result_ref = (*arg1)->attribute();
+        result = (StrokeAttribute *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_attribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_attribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_attribute" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        StrokeAttribute &_result_ref = (*arg1)->attribute();
+        result = (StrokeAttribute *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_attribute(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_StrokeVertexIterator_attribute__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_StrokeVertexIterator_attribute__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeVertexIterator_attribute'.\n  Possible C/C++ prototypes are:\n    attribute()\n    attribute()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_curvilinearAbscissa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_curvilinearAbscissa",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_curvilinearAbscissa" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->curvilinearAbscissa();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_strokeLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_strokeLength",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_strokeLength" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->strokeLength();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setX" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setX" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (*arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setY" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setY" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (*arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeVertexIterator_setPoint",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setPoint" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setPoint" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrokeVertexIterator_setPoint" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      (*arg1)->setPoint(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setPoint",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setPoint" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator_setPoint" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertexIterator_setPoint" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  {
+    try {
+      (*arg1)->setPoint((Geometry::Vec2f const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setPoint(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_StrokeVertexIterator_setPoint__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_StrokeVertexIterator_setPoint__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeVertexIterator_setPoint'.\n  Possible C/C++ prototypes are:\n    setPoint(real,real)\n    setPoint(Geometry::Vec2f const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  StrokeAttribute *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setAttribute",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setAttribute" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator_setAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertexIterator_setAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeAttribute * >(argp2);
+  {
+    try {
+      (*arg1)->setAttribute((StrokeAttribute const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setCurvilinearAbscissa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setCurvilinearAbscissa",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setCurvilinearAbscissa" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setCurvilinearAbscissa" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (*arg1)->setCurvilinearAbscissa(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setStrokeLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setStrokeLength",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setStrokeLength" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setStrokeLength" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (*arg1)->setStrokeLength(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getX" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getY" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getZ" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getPoint3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getPoint3D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getPoint3D" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint3D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getProjectedX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getProjectedX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getProjectedX" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getProjectedY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getProjectedY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getProjectedY" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getProjectedZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getProjectedZ",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getProjectedZ" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->getProjectedZ();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getPoint2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getPoint2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getPoint2D" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getPoint2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Interface0D *arg2 = 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_getFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getFEdge" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Interface0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertexIterator_getFEdge" "', argument " "2"" of type '" "Interface0D &""'"); 
+  }
+  arg2 = reinterpret_cast< Interface0D * >(argp2);
+  {
+    try {
+      result = (FEdge *)(*arg1)->getFEdge(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getId" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_getNature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Nature::VertexNature result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_getNature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_getNature" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (Nature::VertexNature)(*arg1)->getNature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_castToSVertex" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->castToSVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_castToViewVertex" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)(*arg1)->castToViewVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_castToNonTVertex" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)(*arg1)->castToNonTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_castToTVertex" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (TVertex *)(*arg1)->castToTVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_A",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_A" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->A();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_B(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_B",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_B" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->B();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_t2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_t2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_t2d" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (float)(*arg1)->t2d();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setA",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setA" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator_setA" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setA(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SVertex *arg2 = (SVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setB",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setB" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertexIterator_setB" "', argument " "2"" of type '" "SVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< SVertex * >(argp2);
+  {
+    try {
+      (*arg1)->setB(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_setT2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertexIterator_setT2d",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_setT2d" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertexIterator_setT2d" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (*arg1)->setT2d(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_fedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_fedge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_fedge" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (FEdge *)(*arg1)->fedge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_point2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_point2d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_point2d" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point2d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_point3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_point3d",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_point3d" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Geometry::Vec3r const &_result_ref = (*arg1)->point3d();
+        result = (Geometry::Vec3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec3Tdouble_t, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_normal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec3r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_normal",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_normal" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->normal();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3r(static_cast< const Geometry::Vec3r& >(result))), SWIGTYPE_p_VecMat__Vec3Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_shape" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occluders_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occluders_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occluders_begin" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occluders_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  occluder_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occluders_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occluders_end" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->occluders_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new occluder_container::const_iterator(static_cast< const occluder_container::const_iterator& >(result))), SWIGTYPE_p_occluder_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occluders_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occluders_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occluders_empty" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occluders_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occluders_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occluders_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occluders_size" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (int)(*arg1)->occluders_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occludee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Polygon3r *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occludee",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occludee" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      {
+        Polygon3r const &_result_ref = (*arg1)->occludee();
+        result = (Polygon3r *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Polygon3r, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occluded_shape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  SShape *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occluded_shape",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occluded_shape" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (SShape *)(*arg1)->occluded_shape();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SShape, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_occludee_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_occludee_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_occludee_empty" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (bool)(*arg1)->occludee_empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_z_discontinuity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_z_discontinuity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_z_discontinuity" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->z_discontinuity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_curvatureFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_curvatureFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_curvatureFredo" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (real)(*arg1)->curvatureFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertexIterator_directionFredo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeInternal::StrokeVertexIterator *arg1 = (StrokeInternal::StrokeVertexIterator *) 0 ;
+  Geometry::Vec2d result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertexIterator_directionFredo",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertexIterator_directionFredo" "', argument " "1"" of type '" "StrokeInternal::StrokeVertexIterator const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp1);
+  {
+    try {
+      result = (*arg1)->directionFredo();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2d(static_cast< const Geometry::Vec2d& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *StrokeVertexIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_StrokeAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_StrokeAttribute")) SWIG_fail;
+  {
+    try {
+      result = (StrokeAttribute *)new StrokeAttribute();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = 0 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeAttribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeAttribute" "', argument " "1"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeAttribute" "', argument " "1"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (StrokeAttribute *)new StrokeAttribute((StrokeAttribute const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeAttribute__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  float arg6 ;
+  StrokeAttribute *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_StrokeAttribute",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StrokeAttribute" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StrokeAttribute" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StrokeAttribute" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_StrokeAttribute" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_StrokeAttribute" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  ecode6 = SWIG_AsVal_float(obj5, &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_StrokeAttribute" "', argument " "6"" of type '" "float""'");
+  } 
+  arg6 = static_cast< float >(val6);
+  {
+    try {
+      result = (StrokeAttribute *)new StrokeAttribute(arg1,arg2,arg3,arg4,arg5,arg6);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeAttribute__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = 0 ;
+  StrokeAttribute *arg2 = 0 ;
+  float arg3 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_StrokeAttribute",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeAttribute" "', argument " "1"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeAttribute" "', argument " "1"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StrokeAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeAttribute * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StrokeAttribute" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (StrokeAttribute *)new StrokeAttribute((StrokeAttribute const &)*arg1,(StrokeAttribute const &)*arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeAttribute(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[7];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 6); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_StrokeAttribute__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeAttribute__SWIG_1(self, args);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_StrokeAttribute, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_StrokeAttribute__SWIG_3(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_float(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                return _wrap_new_StrokeAttribute__SWIG_2(self, args);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrokeAttribute'.\n  Possible C/C++ prototypes are:\n    StrokeAttribute()\n    StrokeAttribute(StrokeAttribute const &)\n    StrokeAttribute(float,float,float,float,float,float)\n    StrokeAttribute(StrokeAttribute const &,StrokeAttribute const &,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_StrokeAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrokeAttribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrokeAttribute" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getColor",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getColor" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float *)((StrokeAttribute const *)arg1)->getColor();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getColorR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getColorR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getColorR" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getColorR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getColorG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getColorG",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getColorG" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getColorG();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getColorB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getColorB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getColorB" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getColorB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getColorRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getColorRGB",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getColorRGB" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = ((StrokeAttribute const *)arg1)->getColorRGB();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getAlpha",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getAlpha" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getAlpha();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getThickness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getThickness",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getThickness" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float *)((StrokeAttribute const *)arg1)->getThickness();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getThicknessR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getThicknessR",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getThicknessR" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getThicknessR();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getThicknessL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getThicknessL",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getThicknessL" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getThicknessL();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getThicknessRL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_getThicknessRL",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getThicknessRL" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = ((StrokeAttribute const *)arg1)->getThicknessRL();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_isVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeAttribute_isVisible",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_isVisible" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  {
+    try {
+      result = (bool)((StrokeAttribute const *)arg1)->isVisible();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getAttributeReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_getAttributeReal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getAttributeReal" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_getAttributeReal" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = (float)((StrokeAttribute const *)arg1)->getAttributeReal((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getAttributeVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_getAttributeVec2f",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getAttributeVec2f" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_getAttributeVec2f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = ((StrokeAttribute const *)arg1)->getAttributeVec2f((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_getAttributeVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  Geometry::Vec3f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_getAttributeVec3f",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_getAttributeVec3f" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_getAttributeVec3f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = ((StrokeAttribute const *)arg1)->getAttributeVec3f((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec3f(static_cast< const Geometry::Vec3f& >(result))), SWIGTYPE_p_VecMat__Vec3Tfloat_t, SWIG_POINTER_OWN |  0 );
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_isAttributeAvailableReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_isAttributeAvailableReal",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_isAttributeAvailableReal" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_isAttributeAvailableReal" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = (bool)((StrokeAttribute const *)arg1)->isAttributeAvailableReal((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_isAttributeAvailableVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_isAttributeAvailableVec2f",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_isAttributeAvailableVec2f" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_isAttributeAvailableVec2f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = (bool)((StrokeAttribute const *)arg1)->isAttributeAvailableVec2f((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_isAttributeAvailableVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_isAttributeAvailableVec3f",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_isAttributeAvailableVec3f" "', argument " "1"" of type '" "StrokeAttribute const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_isAttributeAvailableVec3f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  {
+    try {
+      result = (bool)((StrokeAttribute const *)arg1)->isAttributeAvailableVec3f((char const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setColor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:StrokeAttribute_setColor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setColor" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeAttribute_setColor" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrokeAttribute_setColor" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StrokeAttribute_setColor" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      (arg1)->setColor(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setColor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  Geometry::Vec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_setColor",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setColor" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_setColor" "', argument " "2"" of type '" "Geometry::Vec3f const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeAttribute_setColor" "', argument " "2"" of type '" "Geometry::Vec3f const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec3f * >(argp2);
+  {
+    try {
+      (arg1)->setColor((Geometry::Vec3f const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setColor(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec3Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_StrokeAttribute_setColor__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_StrokeAttribute_setColor__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeAttribute_setColor'.\n  Possible C/C++ prototypes are:\n    setColor(float,float,float)\n    setColor(Geometry::Vec3f const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_setAlpha",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setAlpha" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeAttribute_setAlpha" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setAlpha(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setThickness__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  float arg2 ;
+  float arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeAttribute_setThickness",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setThickness" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeAttribute_setThickness" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrokeAttribute_setThickness" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      (arg1)->setThickness(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setThickness__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_setThickness",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setThickness" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_setThickness" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeAttribute_setThickness" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  {
+    try {
+      (arg1)->setThickness((Geometry::Vec2f const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setThickness(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_StrokeAttribute_setThickness__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeAttribute, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_StrokeAttribute_setThickness__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeAttribute_setThickness'.\n  Possible C/C++ prototypes are:\n    setThickness(float,float)\n    setThickness(Geometry::Vec2f const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeAttribute_setVisible",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setVisible" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeAttribute_setVisible" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->setVisible(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setAttributeReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  float arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeAttribute_setAttributeReal",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setAttributeReal" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_setAttributeReal" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrokeAttribute_setAttributeReal" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      (arg1)->setAttributeReal((char const *)arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setAttributeVec2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  Geometry::Vec2f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeAttribute_setAttributeVec2f",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setAttributeVec2f" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_setAttributeVec2f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrokeAttribute_setAttributeVec2f" "', argument " "3"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeAttribute_setAttributeVec2f" "', argument " "3"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2f * >(argp3);
+  {
+    try {
+      (arg1)->setAttributeVec2f((char const *)arg2,(Geometry::Vec2f const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeAttribute_setAttributeVec3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeAttribute *arg1 = (StrokeAttribute *) 0 ;
+  char *arg2 = (char *) 0 ;
+  Geometry::Vec3f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeAttribute_setAttributeVec3f",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeAttribute_setAttributeVec3f" "', argument " "1"" of type '" "StrokeAttribute *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeAttribute * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeAttribute_setAttributeVec3f" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StrokeAttribute_setAttributeVec3f" "', argument " "3"" of type '" "Geometry::Vec3f const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeAttribute_setAttributeVec3f" "', argument " "3"" of type '" "Geometry::Vec3f const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec3f * >(argp3);
+  {
+    try {
+      (arg1)->setAttributeVec3f((char const *)arg2,(Geometry::Vec3f const &)*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *StrokeAttribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeAttribute, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_getExactTypeName" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = ((StrokeVertex const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_StrokeVertex")) SWIG_fail;
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_StrokeVertex,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "StrokeVertex const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "StrokeVertex const &""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex((StrokeVertex const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CurvePoint *arg1 = (CurvePoint *) 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CurvePoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "CurvePoint *""'"); 
+  }
+  arg1 = reinterpret_cast< CurvePoint * >(argp1);
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  StrokeVertex *arg2 = (StrokeVertex *) 0 ;
+  float arg3 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_StrokeVertex",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StrokeVertex" "', argument " "2"" of type '" "StrokeVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeVertex * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StrokeVertex" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SVertex *arg1 = (SVertex *) 0 ;
+  StrokeAttribute *arg2 = 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_StrokeVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrokeVertex" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StrokeVertex" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrokeVertex" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeAttribute * >(argp2);
+  {
+    try {
+      result = (StrokeVertex *)new StrokeVertex(arg1,(StrokeAttribute const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeVertex(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_StrokeVertex__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeVertex__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeVertex__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CurvePoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeVertex__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_StrokeAttribute, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_StrokeVertex__SWIG_5(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_StrokeVertex__SWIG_4(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrokeVertex'.\n  Possible C/C++ prototypes are:\n    StrokeVertex()\n    StrokeVertex(StrokeVertex const &)\n    StrokeVertex(SVertex *)\n    StrokeVertex(CurvePoint *)\n    StrokeVertex(StrokeVertex *,StrokeVertex *,float)\n    StrokeVertex(SVertex *,StrokeAttribute const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_StrokeVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrokeVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrokeVertex" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_x(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_x",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_x" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (real)((StrokeVertex const *)arg1)->x();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_y",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_y" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (real)((StrokeVertex const *)arg1)->y();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_getPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  Geometry::Vec2f result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_getPoint",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_getPoint" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (arg1)->getPoint();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2f(static_cast< const Geometry::Vec2f& >(result))), SWIGTYPE_p_VecMat__Vec2Tfloat_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_attribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_attribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_attribute" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      {
+        StrokeAttribute const &_result_ref = ((StrokeVertex const *)arg1)->attribute();
+        result = (StrokeAttribute *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_attribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  StrokeAttribute *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_attribute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_attribute" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      {
+        StrokeAttribute &_result_ref = (arg1)->attribute();
+        result = (StrokeAttribute *) &_result_ref;
+      }
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeAttribute, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_attribute(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_StrokeVertex_attribute__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_StrokeVertex_attribute__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeVertex_attribute'.\n  Possible C/C++ prototypes are:\n    attribute()\n    attribute()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_curvilinearAbscissa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_curvilinearAbscissa",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_curvilinearAbscissa" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (float)((StrokeVertex const *)arg1)->curvilinearAbscissa();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_strokeLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_strokeLength",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_strokeLength" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (float)((StrokeVertex const *)arg1)->strokeLength();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeVertex_u",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_u" "', argument " "1"" of type '" "StrokeVertex const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  {
+    try {
+      result = (float)((StrokeVertex const *)arg1)->u();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setX",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setX" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertex_setX" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (arg1)->setX(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  real arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setY",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setY" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertex_setY" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  {
+    try {
+      (arg1)->setY(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:StrokeVertex_setPoint",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setPoint" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertex_setPoint" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StrokeVertex_setPoint" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      (arg1)->setPoint(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  Geometry::Vec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setPoint",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setPoint" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertex_setPoint" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertex_setPoint" "', argument " "2"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2f * >(argp2);
+  {
+    try {
+      (arg1)->setPoint((Geometry::Vec2f const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setPoint(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tfloat_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_StrokeVertex_setPoint__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_StrokeVertex, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_StrokeVertex_setPoint__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'StrokeVertex_setPoint'.\n  Possible C/C++ prototypes are:\n    setPoint(real,real)\n    setPoint(Geometry::Vec2f const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  StrokeAttribute *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setAttribute",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setAttribute" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_StrokeAttribute,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeVertex_setAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeVertex_setAttribute" "', argument " "2"" of type '" "StrokeAttribute const &""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeAttribute * >(argp2);
+  {
+    try {
+      (arg1)->setAttribute((StrokeAttribute const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setCurvilinearAbscissa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setCurvilinearAbscissa",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setCurvilinearAbscissa" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertex_setCurvilinearAbscissa" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setCurvilinearAbscissa(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeVertex_setStrokeLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeVertex *arg1 = (StrokeVertex *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeVertex_setStrokeLength",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeVertex_setStrokeLength" "', argument " "1"" of type '" "StrokeVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeVertex * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StrokeVertex_setStrokeLength" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setStrokeLength(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *StrokeVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeVertex, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Stroke_getExactTypeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getExactTypeName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getExactTypeName" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->getExactTypeName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Id result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getId" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->getId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Id(static_cast< const Id& >(result))), SWIGTYPE_p_Id, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Stroke__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_Stroke")) SWIG_fail;
+  {
+    try {
+      result = (Stroke *)new Stroke();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Stroke, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Stroke__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = 0 ;
+  Stroke *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Stroke",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Stroke,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Stroke" "', argument " "1"" of type '" "Stroke const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Stroke" "', argument " "1"" of type '" "Stroke const &""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (Stroke *)new Stroke((Stroke const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Stroke, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_Stroke(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_Stroke__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_Stroke__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Stroke'.\n  Possible C/C++ prototypes are:\n    Stroke()\n    Stroke(Stroke const &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Stroke(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Stroke",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Stroke" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_ComputeSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  int arg2 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_ComputeSampling",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_ComputeSampling" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_ComputeSampling" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      result = (float)(arg1)->ComputeSampling(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_Resample__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_Resample",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_Resample" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_Resample" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      (arg1)->Resample(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_Resample__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_Resample",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_Resample" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_Resample" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->Resample(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_Resample(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Stroke_Resample__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Stroke_Resample__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_Resample'.\n  Possible C/C++ prototypes are:\n    Resample(int)\n    Resample(float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_RemoveVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeVertex *arg2 = (StrokeVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_RemoveVertex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_RemoveVertex" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_RemoveVertex" "', argument " "2"" of type '" "StrokeVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeVertex * >(argp2);
+  {
+    try {
+      (arg1)->RemoveVertex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_InsertVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeVertex *arg2 = (StrokeVertex *) 0 ;
+  StrokeInternal::StrokeVertexIterator arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Stroke_InsertVertex",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_InsertVertex" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_InsertVertex" "', argument " "2"" of type '" "StrokeVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeVertex * >(argp2);
+  {
+    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_StrokeInternal__StrokeVertexIterator,  0  | 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Stroke_InsertVertex" "', argument " "3"" of type '" "StrokeInternal::StrokeVertexIterator""'"); 
+    }  
+    if (!argp3) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stroke_InsertVertex" "', argument " "3"" of type '" "StrokeInternal::StrokeVertexIterator""'");
+    } else {
+      StrokeInternal::StrokeVertexIterator * temp = reinterpret_cast< StrokeInternal::StrokeVertexIterator * >(argp3);
+      arg3 = *temp;
+      if (SWIG_IsNewObj(res3)) delete temp;
+    }
+  }
+  {
+    try {
+      (arg1)->InsertVertex(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_Render(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeRenderer *arg2 = (StrokeRenderer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_Render",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_Render" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeRenderer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_Render" "', argument " "2"" of type '" "StrokeRenderer const *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeRenderer * >(argp2);
+  {
+    try {
+      (arg1)->Render((StrokeRenderer const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_RenderBasic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeRenderer *arg2 = (StrokeRenderer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_RenderBasic",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_RenderBasic" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeRenderer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_RenderBasic" "', argument " "2"" of type '" "StrokeRenderer const *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeRenderer * >(argp2);
+  {
+    try {
+      (arg1)->RenderBasic((StrokeRenderer const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getLength2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getLength2D",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getLength2D" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (real)((Stroke const *)arg1)->getLength2D();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getMediumType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::MediumType result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getMediumType",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getMediumType" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (Stroke::MediumType)((Stroke const *)arg1)->getMediumType();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getTextureId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getTextureId",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getTextureId" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (unsigned int)(arg1)->getTextureId();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_hasTips(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_hasTips",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_hasTips" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (bool)((Stroke const *)arg1)->hasTips();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_vertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_vertices_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_vertices_size" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (int)((Stroke const *)arg1)->vertices_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::viewedge_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_viewedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_viewedges_begin" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->viewedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Stroke::viewedge_container::const_iterator(static_cast< const Stroke::viewedge_container::const_iterator& >(result))), SWIGTYPE_p_Stroke__viewedge_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::viewedge_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_viewedges_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_viewedges_begin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->viewedges_begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Stroke::viewedge_container::iterator(static_cast< const Stroke::viewedge_container::iterator& >(result))), SWIGTYPE_p_Stroke__viewedge_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_viewedges_begin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_viewedges_begin__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_viewedges_begin'.\n  Possible C/C++ prototypes are:\n    viewedges_begin()\n    viewedges_begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::viewedge_container::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_viewedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_viewedges_end" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->viewedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Stroke::viewedge_container::const_iterator(static_cast< const Stroke::viewedge_container::const_iterator& >(result))), SWIGTYPE_p_Stroke__viewedge_container__const_iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::viewedge_container::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_viewedges_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_viewedges_end" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->viewedges_end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Stroke::viewedge_container::iterator(static_cast< const Stroke::viewedge_container::iterator& >(result))), SWIGTYPE_p_Stroke__viewedge_container__iterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_viewedges_end__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_viewedges_end__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_viewedges_end'.\n  Possible C/C++ prototypes are:\n    viewedges_end()\n    viewedges_end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_viewedges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_viewedges_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_viewedges_size" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (int)((Stroke const *)arg1)->viewedges_size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getBeginningOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Geometry::Vec2r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getBeginningOrientation",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getBeginningOrientation" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->getBeginningOrientation();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2r(static_cast< const Geometry::Vec2r& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getBeginningOrientationX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getBeginningOrientationX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getBeginningOrientationX" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (real)((Stroke const *)arg1)->getBeginningOrientationX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getBeginningOrientationY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getBeginningOrientationY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getBeginningOrientationY" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (real)((Stroke const *)arg1)->getBeginningOrientationY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getEndingOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Geometry::Vec2r result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getEndingOrientation",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getEndingOrientation" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = ((Stroke const *)arg1)->getEndingOrientation();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Geometry::Vec2r(static_cast< const Geometry::Vec2r& >(result))), SWIGTYPE_p_VecMat__Vec2Tdouble_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getEndingOrientationX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getEndingOrientationX",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getEndingOrientationX" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (real)((Stroke const *)arg1)->getEndingOrientationX();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_getEndingOrientationY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_getEndingOrientationY",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_getEndingOrientationY" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (real)((Stroke const *)arg1)->getEndingOrientationY();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Id *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setId" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Id,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stroke_setId" "', argument " "2"" of type '" "Id const &""'"); 
+  }
+  arg2 = reinterpret_cast< Id * >(argp2);
+  {
+    try {
+      (arg1)->setId((Id const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setLength",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setLength" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setLength" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      (arg1)->setLength(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setMediumType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Stroke::MediumType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setMediumType",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setMediumType" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setMediumType" "', argument " "2"" of type '" "Stroke::MediumType""'");
+  } 
+  arg2 = static_cast< Stroke::MediumType >(val2);
+  {
+    try {
+      (arg1)->setMediumType(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setTextureId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setTextureId",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setTextureId" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setTextureId" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->setTextureId(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setTips(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setTips",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setTips" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setTips" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->setTips(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeVertex *arg2 = (StrokeVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_push_back" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_push_back" "', argument " "2"" of type '" "StrokeVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeVertex * >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_push_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeVertex *arg2 = (StrokeVertex *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_push_front",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_push_front" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_push_front" "', argument " "2"" of type '" "StrokeVertex *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeVertex * >(argp2);
+  {
+    try {
+      (arg1)->push_front(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_AddViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  ViewEdge *arg2 = (ViewEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_AddViewEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_AddViewEdge" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ViewEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_AddViewEdge" "', argument " "2"" of type '" "ViewEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< ViewEdge * >(argp2);
+  {
+    try {
+      (arg1)->AddViewEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setBeginningOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setBeginningOrientation",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setBeginningOrientation" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_setBeginningOrientation" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stroke_setBeginningOrientation" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  {
+    try {
+      (arg1)->setBeginningOrientation((Geometry::Vec2r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setBeginningOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Stroke_setBeginningOrientation",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setBeginningOrientation" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setBeginningOrientation" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Stroke_setBeginningOrientation" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      (arg1)->setBeginningOrientation(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setBeginningOrientation(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Stroke_setBeginningOrientation__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Stroke_setBeginningOrientation__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_setBeginningOrientation'.\n  Possible C/C++ prototypes are:\n    setBeginningOrientation(Geometry::Vec2r const &)\n    setBeginningOrientation(real,real)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setEndingOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Geometry::Vec2r *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_setEndingOrientation",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setEndingOrientation" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Stroke_setEndingOrientation" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Stroke_setEndingOrientation" "', argument " "2"" of type '" "Geometry::Vec2r const &""'"); 
+  }
+  arg2 = reinterpret_cast< Geometry::Vec2r * >(argp2);
+  {
+    try {
+      (arg1)->setEndingOrientation((Geometry::Vec2r const &)*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setEndingOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Stroke_setEndingOrientation",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_setEndingOrientation" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_setEndingOrientation" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Stroke_setEndingOrientation" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  {
+    try {
+      (arg1)->setEndingOrientation(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_setEndingOrientation(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__Vec2Tdouble_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Stroke_setEndingOrientation__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Stroke_setEndingOrientation__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_setEndingOrientation'.\n  Possible C/C++ prototypes are:\n    setEndingOrientation(Geometry::Vec2r const &)\n    setEndingOrientation(real,real)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_strokeVerticesBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  float arg2 ;
+  StrokeInternal::StrokeVertexIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_strokeVerticesBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_strokeVerticesBegin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_strokeVerticesBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->strokeVerticesBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new StrokeInternal::StrokeVertexIterator(static_cast< const StrokeInternal::StrokeVertexIterator& >(result))), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_strokeVerticesBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeInternal::StrokeVertexIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_strokeVerticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_strokeVerticesBegin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->strokeVerticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new StrokeInternal::StrokeVertexIterator(static_cast< const StrokeInternal::StrokeVertexIterator& >(result))), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_strokeVerticesBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_strokeVerticesBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Stroke_strokeVerticesBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_strokeVerticesBegin'.\n  Possible C/C++ prototypes are:\n    strokeVerticesBegin(float)\n    strokeVerticesBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_strokeVerticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  StrokeInternal::StrokeVertexIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_strokeVerticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_strokeVerticesEnd" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->strokeVerticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new StrokeInternal::StrokeVertexIterator(static_cast< const StrokeInternal::StrokeVertexIterator& >(result))), SWIGTYPE_p_StrokeInternal__StrokeVertexIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_strokeVerticesSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  unsigned int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_strokeVerticesSize",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_strokeVerticesSize" "', argument " "1"" of type '" "Stroke const *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (unsigned int)((Stroke const *)arg1)->strokeVerticesSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_verticesBegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_verticesBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_verticesBegin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_verticesEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_verticesEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_verticesEnd" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->verticesEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsBegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_pointsBegin",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_pointsBegin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_pointsBegin" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsBegin(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsBegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_pointsBegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_pointsBegin" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsBegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsBegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_pointsBegin__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Stroke_pointsBegin__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_pointsBegin'.\n  Possible C/C++ prototypes are:\n    pointsBegin(float)\n    pointsBegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  float arg2 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Stroke_pointsEnd",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_pointsEnd" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Stroke_pointsEnd" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (arg1)->pointsEnd(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = (Stroke *) 0 ;
+  Interface0DIterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Stroke_pointsEnd",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Stroke_pointsEnd" "', argument " "1"" of type '" "Stroke *""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (arg1)->pointsEnd();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new Interface0DIterator(static_cast< const Interface0DIterator& >(result))), SWIGTYPE_p_Interface0DIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Stroke_pointsEnd(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Stroke_pointsEnd__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Stroke, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Stroke_pointsEnd__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Stroke_pointsEnd'.\n  Possible C/C++ prototypes are:\n    pointsEnd(float)\n    pointsEnd()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Stroke_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Stroke, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  PyObject **arg2 = (PyObject **) 0 ;
+  swig::PySwigIterator *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  arg2 = &obj0;
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_iterator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_iterator" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (swig::PySwigIterator *)std_vector_Sl_StrokeShader_Sm__Sg__iterator(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer___nonzero__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___nonzero__" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (bool)std_vector_Sl_StrokeShader_Sm__Sg____nonzero__((std::vector<StrokeShader * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer___len__",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___len__" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = std_vector_Sl_StrokeShader_Sm__Sg____len__((std::vector<StrokeShader * > const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_pop" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      try {
+        result = (std::vector<StrokeShader * >::value_type)std_vector_Sl_StrokeShader_Sm__Sg__pop(arg1);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  std::vector<StrokeShader * >::difference_type arg3 ;
+  std::vector<StrokeShader *,std::allocator<StrokeShader * > > *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___getslice__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___getslice__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShadersContainer___getslice__" "', argument " "3"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<StrokeShader * >::difference_type >(val3);
+  {
+    try {
+      try {
+        result = (std::vector<StrokeShader *,std::allocator<StrokeShader * > > *)std_vector_Sl_StrokeShader_Sm__Sg____getslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  std::vector<StrokeShader * >::difference_type arg3 ;
+  std::vector<StrokeShader *,std::allocator<StrokeShader * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ShadersContainer___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___setslice__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___setslice__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShadersContainer___setslice__" "', argument " "3"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<StrokeShader * >::difference_type >(val3);
+  {
+    std::vector<StrokeShader*,std::allocator<StrokeShader * > > *ptr = (std::vector<StrokeShader*,std::allocator<StrokeShader * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShadersContainer___setslice__" "', argument " "4"" of type '" "std::vector<StrokeShader *,std::allocator<StrokeShader * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShadersContainer___setslice__" "', argument " "4"" of type '" "std::vector<StrokeShader *,std::allocator<StrokeShader * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  {
+    try {
+      try {
+        std_vector_Sl_StrokeShader_Sm__Sg____setslice__(arg1,arg2,arg3,(std::vector<StrokeShader *,std::allocator<StrokeShader * > > const &)*arg4);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      catch(std::invalid_argument &_e) {
+        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  std::vector<StrokeShader * >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___delslice__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___delslice__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShadersContainer___delslice__" "', argument " "3"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector<StrokeShader * >::difference_type >(val3);
+  {
+    try {
+      try {
+        std_vector_Sl_StrokeShader_Sm__Sg____delslice__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer___delitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___delitem__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___delitem__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  {
+    try {
+      try {
+        std_vector_Sl_StrokeShader_Sm__Sg____delitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  std::vector<StrokeShader * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer___getitem__",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___getitem__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___getitem__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  {
+    try {
+      try {
+        result = (std::vector<StrokeShader * >::value_type)std_vector_Sl_StrokeShader_Sm__Sg____getitem__(arg1,arg2);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::difference_type arg2 ;
+  std::vector<StrokeShader * >::value_type arg3 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer___setitem__" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer___setitem__" "', argument " "2"" of type '" "std::vector<StrokeShader * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::difference_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShadersContainer___setitem__" "', argument " "3"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp3);
+  {
+    try {
+      try {
+        std_vector_Sl_StrokeShader_Sm__Sg____setitem__(arg1,arg2,arg3);
+      }
+      catch(std::out_of_range &_e) {
+        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::value_type arg2 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_append",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_append" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShadersContainer_append" "', argument " "2"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp2);
+  {
+    try {
+      std_vector_Sl_StrokeShader_Sm__Sg__append(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShadersContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ShadersContainer")) SWIG_fail;
+  {
+    try {
+      result = (std::vector<StrokeShader * > *)new std::vector<StrokeShader * >();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShadersContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = 0 ;
+  std::vector<StrokeShader * > *result = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ShadersContainer",&obj0)) SWIG_fail;
+  {
+    std::vector<StrokeShader*,std::allocator<StrokeShader * > > *ptr = (std::vector<StrokeShader*,std::allocator<StrokeShader * > > *)0;
+    res1 = swig::asptr(obj0, &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShadersContainer" "', argument " "1"" of type '" "std::vector<StrokeShader * > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShadersContainer" "', argument " "1"" of type '" "std::vector<StrokeShader * > const &""'"); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      result = (std::vector<StrokeShader * > *)new std::vector<StrokeShader * >((std::vector<StrokeShader * > const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_empty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_empty" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (bool)((std::vector<StrokeShader * > const *)arg1)->empty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_size",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_size" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->size();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_clear" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      (arg1)->clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_swap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_swap" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShadersContainer_swap" "', argument " "2"" of type '" "std::vector<StrokeShader * > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShadersContainer_swap" "', argument " "2"" of type '" "std::vector<StrokeShader * > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<StrokeShader * > * >(argp2);
+  {
+    try {
+      (arg1)->swap(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  SwigValueWrapper<std::allocator<StrokeShader * > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_get_allocator" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->get_allocator();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new std::vector<StrokeShader * >::allocator_type(static_cast< const std::vector<StrokeShader * >::allocator_type& >(result))), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_begin" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_begin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_begin" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->begin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_begin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_begin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_begin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_end" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::const_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_end",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_end" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->end();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::const_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_end(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_end__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_end__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_rbegin" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_rbegin",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_rbegin" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->rbegin();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rbegin(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_rbegin__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_rbegin__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_rend" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::const_reverse_iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_rend",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_rend" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->rend();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::const_reverse_iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_rend(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_rend__SWIG_0(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_ShadersContainer_rend__SWIG_1(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShadersContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * >::size_type arg1 ;
+  std::vector<StrokeShader * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ShadersContainer",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShadersContainer" "', argument " "1"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<StrokeShader * >::size_type >(val1);
+  {
+    try {
+      result = (std::vector<StrokeShader * > *)new std::vector<StrokeShader * >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_pop_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_pop_back" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      (arg1)->pop_back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_resize",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_resize" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer_resize" "', argument " "2"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::size_type >(val2);
+  {
+    try {
+      (arg1)->resize(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator arg2 ;
+  std::vector<StrokeShader * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_erase",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_erase" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator arg2 ;
+  std::vector<StrokeShader * >::iterator arg3 ;
+  std::vector<StrokeShader * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  swig::PySwigIterator *iter3 = 0 ;
+  int res3 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer_erase",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_erase" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res3) || !iter3) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "3"" of type '" "std::vector<StrokeShader * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter3);
+    if (iter_t) {
+      arg3 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_erase" "', argument " "3"" of type '" "std::vector<StrokeShader * >::iterator""'");
+    }
+  }
+  {
+    try {
+      result = (arg1)->erase(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_erase(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter) != 0));
+      if (_v) {
+        return _wrap_ShadersContainer_erase__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter) != 0));
+      if (_v) {
+        swig::PySwigIterator *iter = 0;
+        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter) != 0));
+        if (_v) {
+          return _wrap_ShadersContainer_erase__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<StrokeShader * >::iterator)\n    erase(std::vector<StrokeShader * >::iterator,std::vector<StrokeShader * >::iterator)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShadersContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * >::size_type arg1 ;
+  std::vector<StrokeShader * >::value_type arg2 = (std::vector<StrokeShader * >::value_type) 0 ;
+  std::vector<StrokeShader * > *result = 0 ;
+  size_t val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ShadersContainer",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShadersContainer" "', argument " "1"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg1 = static_cast< std::vector<StrokeShader * >::size_type >(val1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ShadersContainer" "', argument " "2"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp2);
+  {
+    try {
+      result = (std::vector<StrokeShader * > *)new std::vector<StrokeShader * >(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ShadersContainer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ShadersContainer__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ShadersContainer__SWIG_2(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ShadersContainer__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_size_t(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_ShadersContainer__SWIG_3(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ShadersContainer'.\n  Possible C/C++ prototypes are:\n    std::vector<(p.StrokeShader)>()\n    std::vector<(p.StrokeShader)>(std::vector<StrokeShader * > const &)\n    std::vector<(p.StrokeShader)>(std::vector<StrokeShader * >::size_type)\n    std::vector<(p.StrokeShader)>(std::vector<StrokeShader * >::size_type,std::vector<StrokeShader * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::value_type arg2 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_push_back",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_push_back" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShadersContainer_push_back" "', argument " "2"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp2);
+  {
+    try {
+      (arg1)->push_back(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_front",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_front" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (std::vector<StrokeShader * >::value_type)((std::vector<StrokeShader * > const *)arg1)->front();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::value_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_back",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_back" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = (std::vector<StrokeShader * >::value_type)((std::vector<StrokeShader * > const *)arg1)->back();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type arg2 ;
+  std::vector<StrokeShader * >::value_type arg3 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer_assign",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_assign" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer_assign" "', argument " "2"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShadersContainer_assign" "', argument " "3"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->assign(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type arg2 ;
+  std::vector<StrokeShader * >::value_type arg3 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer_resize",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_resize" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer_resize" "', argument " "2"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::size_type >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShadersContainer_resize" "', argument " "3"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp3);
+  {
+    try {
+      (arg1)->resize(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_resize(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_ShadersContainer_resize__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_size_t(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ShadersContainer_resize__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<StrokeShader * >::size_type)\n    resize(std::vector<StrokeShader * >::size_type,std::vector<StrokeShader * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator arg2 ;
+  std::vector<StrokeShader * >::value_type arg3 = (std::vector<StrokeShader * >::value_type) 0 ;
+  std::vector<StrokeShader * >::iterator result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ShadersContainer_insert",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_insert" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_insert" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_insert" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+    }
+  }
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShadersContainer_insert" "', argument " "3"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg3 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp3);
+  {
+    try {
+      result = (arg1)->insert(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<StrokeShader * >::iterator & >(result)),
+    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::iterator arg2 ;
+  std::vector<StrokeShader * >::size_type arg3 ;
+  std::vector<StrokeShader * >::value_type arg4 = (std::vector<StrokeShader * >::value_type) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  swig::PySwigIterator *iter2 = 0 ;
+  int res2 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:ShadersContainer_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_insert" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
+  if (!SWIG_IsOK(res2) || !iter2) {
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_insert" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+  } else {
+    swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter2);
+    if (iter_t) {
+      arg2 = iter_t->get_current();
+    } else {
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShadersContainer_insert" "', argument " "2"" of type '" "std::vector<StrokeShader * >::iterator""'");
+    }
+  }
+  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShadersContainer_insert" "', argument " "3"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg3 = static_cast< std::vector<StrokeShader * >::size_type >(val3);
+  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShadersContainer_insert" "', argument " "4"" of type '" "std::vector<StrokeShader * >::value_type""'"); 
+  }
+  arg4 = reinterpret_cast< std::vector<StrokeShader * >::value_type >(argp4);
+  {
+    try {
+      (arg1)->insert(arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_insert(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter) != 0));
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_ShadersContainer_insert__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector<StrokeShader*,std::allocator<StrokeShader * > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      swig::PySwigIterator *iter = 0;
+      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<StrokeShader * >::iterator > *>(iter) != 0));
+      if (_v) {
+        {
+          int res = SWIG_AsVal_size_t(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_ShadersContainer_insert__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShadersContainer_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<StrokeShader * >::iterator,std::vector<StrokeShader * >::value_type)\n    insert(std::vector<StrokeShader * >::iterator,std::vector<StrokeShader * >::size_type,std::vector<StrokeShader * >::value_type)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  size_t val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ShadersContainer_reserve",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_reserve" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShadersContainer_reserve" "', argument " "2"" of type '" "std::vector<StrokeShader * >::size_type""'");
+  } 
+  arg2 = static_cast< std::vector<StrokeShader * >::size_type >(val2);
+  {
+    try {
+      (arg1)->reserve(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ShadersContainer_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  std::vector<StrokeShader * >::size_type result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ShadersContainer_capacity",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShadersContainer_capacity" "', argument " "1"" of type '" "std::vector<StrokeShader * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      result = ((std::vector<StrokeShader * > const *)arg1)->capacity();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ShadersContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector<StrokeShader * > *arg1 = (std::vector<StrokeShader * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ShadersContainer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShadersContainer" "', argument " "1"" of type '" "std::vector<StrokeShader * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector<StrokeShader * > * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ShadersContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_StrokeShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  StrokeShader *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeShader",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  {
+    try {
+      if ( arg1 != Py_None ) {
+        /* subclassed */
+        result = (StrokeShader *)new SwigDirector_StrokeShader(arg1); 
+      } else {
+        result = (StrokeShader *)new StrokeShader(); 
+      }
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_StrokeShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShader *arg1 = (StrokeShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrokeShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrokeShader" "', argument " "1"" of type '" "StrokeShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShader *arg1 = (StrokeShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:StrokeShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeShader_getName" "', argument " "1"" of type '" "StrokeShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShader * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((StrokeShader const *)arg1)->StrokeShader::getName();
+        } else {
+          result = ((StrokeShader const *)arg1)->getName();
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShader *arg1 = (StrokeShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeShader_shade" "', argument " "1"" of type '" "StrokeShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    {
+      try {
+        if (upcall) {
+          ((StrokeShader const *)arg1)->StrokeShader::shade(*arg2);
+        } else {
+          ((StrokeShader const *)arg1)->shade(*arg2);
+        }
+      }
+      //    catch (Swig::DirectorTypeMismatch&) {
+      //      cout << "Warning: return type mismatch" << endl;
+      //    }
+      catch (Swig::DirectorException&) {
+        cout << "Warning: director exception catched" << endl;
+      }
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_StrokeShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShader *arg1 = (StrokeShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_StrokeShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_StrokeShader" "', argument " "1"" of type '" "StrokeShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShader * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *StrokeShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ConstantThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::ConstantThicknessShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ConstantThicknessShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantThicknessShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::ConstantThicknessShader *)new StrokeShaders::ConstantThicknessShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ConstantThicknessShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ConstantThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantThicknessShader *arg1 = (StrokeShaders::ConstantThicknessShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstantThicknessShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantThicknessShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantThicknessShader" "', argument " "1"" of type '" "StrokeShaders::ConstantThicknessShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantThicknessShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantThicknessShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantThicknessShader *arg1 = (StrokeShaders::ConstantThicknessShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ConstantThicknessShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantThicknessShader_getName" "', argument " "1"" of type '" "StrokeShaders::ConstantThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantThicknessShader * >(argp1);
+  {
+    try {
+      result = ((StrokeShaders::ConstantThicknessShader const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantThicknessShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantThicknessShader *arg1 = (StrokeShaders::ConstantThicknessShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ConstantThicknessShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantThicknessShader_shade" "', argument " "1"" of type '" "StrokeShaders::ConstantThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantThicknessShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ConstantThicknessShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ConstantThicknessShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ConstantThicknessShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ConstantExternThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::ConstantExternThicknessShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ConstantExternThicknessShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantExternThicknessShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::ConstantExternThicknessShader *)new StrokeShaders::ConstantExternThicknessShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ConstantExternThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantExternThicknessShader *arg1 = (StrokeShaders::ConstantExternThicknessShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstantExternThicknessShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantExternThicknessShader" "', argument " "1"" of type '" "StrokeShaders::ConstantExternThicknessShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantExternThicknessShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantExternThicknessShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantExternThicknessShader *arg1 = (StrokeShaders::ConstantExternThicknessShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ConstantExternThicknessShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantExternThicknessShader_getName" "', argument " "1"" of type '" "StrokeShaders::ConstantExternThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantExternThicknessShader * >(argp1);
+  {
+    try {
+      result = ((StrokeShaders::ConstantExternThicknessShader const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantExternThicknessShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantExternThicknessShader *arg1 = (StrokeShaders::ConstantExternThicknessShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ConstantExternThicknessShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantExternThicknessShader_shade" "', argument " "1"" of type '" "StrokeShaders::ConstantExternThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantExternThicknessShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantExternThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantExternThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ConstantExternThicknessShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ConstantExternThicknessShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ConstantExternThicknessShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_IncreasingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  StrokeShaders::IncreasingThicknessShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_IncreasingThicknessShader",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncreasingThicknessShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IncreasingThicknessShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::IncreasingThicknessShader *)new StrokeShaders::IncreasingThicknessShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__IncreasingThicknessShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_IncreasingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::IncreasingThicknessShader *arg1 = (StrokeShaders::IncreasingThicknessShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncreasingThicknessShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__IncreasingThicknessShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncreasingThicknessShader" "', argument " "1"" of type '" "StrokeShaders::IncreasingThicknessShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::IncreasingThicknessShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_IncreasingThicknessShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::IncreasingThicknessShader *arg1 = (StrokeShaders::IncreasingThicknessShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:IncreasingThicknessShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__IncreasingThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncreasingThicknessShader_shade" "', argument " "1"" of type '" "StrokeShaders::IncreasingThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::IncreasingThicknessShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncreasingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncreasingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::IncreasingThicknessShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *IncreasingThicknessShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__IncreasingThicknessShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ConstrainedIncreasingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  StrokeShaders::ConstrainedIncreasingThicknessShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ConstrainedIncreasingThicknessShader",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstrainedIncreasingThicknessShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstrainedIncreasingThicknessShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedIncreasingThicknessShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (StrokeShaders::ConstrainedIncreasingThicknessShader *)new StrokeShaders::ConstrainedIncreasingThicknessShader(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ConstrainedIncreasingThicknessShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ConstrainedIncreasingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstrainedIncreasingThicknessShader *arg1 = (StrokeShaders::ConstrainedIncreasingThicknessShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstrainedIncreasingThicknessShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstrainedIncreasingThicknessShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstrainedIncreasingThicknessShader" "', argument " "1"" of type '" "StrokeShaders::ConstrainedIncreasingThicknessShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstrainedIncreasingThicknessShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstrainedIncreasingThicknessShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstrainedIncreasingThicknessShader *arg1 = (StrokeShaders::ConstrainedIncreasingThicknessShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ConstrainedIncreasingThicknessShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstrainedIncreasingThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedIncreasingThicknessShader_shade" "', argument " "1"" of type '" "StrokeShaders::ConstrainedIncreasingThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstrainedIncreasingThicknessShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedIncreasingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedIncreasingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ConstrainedIncreasingThicknessShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ConstrainedIncreasingThicknessShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ConstrainedIncreasingThicknessShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_LengthDependingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  StrokeShaders::LengthDependingThicknessShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_LengthDependingThicknessShader",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LengthDependingThicknessShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LengthDependingThicknessShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::LengthDependingThicknessShader *)new StrokeShaders::LengthDependingThicknessShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__LengthDependingThicknessShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_LengthDependingThicknessShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::LengthDependingThicknessShader *arg1 = (StrokeShaders::LengthDependingThicknessShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_LengthDependingThicknessShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__LengthDependingThicknessShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LengthDependingThicknessShader" "', argument " "1"" of type '" "StrokeShaders::LengthDependingThicknessShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::LengthDependingThicknessShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_LengthDependingThicknessShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::LengthDependingThicknessShader *arg1 = (StrokeShaders::LengthDependingThicknessShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:LengthDependingThicknessShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__LengthDependingThicknessShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LengthDependingThicknessShader_shade" "', argument " "1"" of type '" "StrokeShaders::LengthDependingThicknessShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::LengthDependingThicknessShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LengthDependingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LengthDependingThicknessShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::LengthDependingThicknessShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *LengthDependingThicknessShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__LengthDependingThicknessShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ThicknessVariationPatternShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  float arg2 ;
+  float arg3 ;
+  bool arg4 ;
+  StrokeShaders::ThicknessVariationPatternShader *result = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ThicknessVariationPatternShader",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ThicknessVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ThicknessVariationPatternShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ThicknessVariationPatternShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ThicknessVariationPatternShader" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  {
+    try {
+      result = (StrokeShaders::ThicknessVariationPatternShader *)new StrokeShaders::ThicknessVariationPatternShader(arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessVariationPatternShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  float arg2 ;
+  float arg3 ;
+  StrokeShaders::ThicknessVariationPatternShader *result = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ThicknessVariationPatternShader",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ThicknessVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ThicknessVariationPatternShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ThicknessVariationPatternShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (StrokeShaders::ThicknessVariationPatternShader *)new StrokeShaders::ThicknessVariationPatternShader(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessVariationPatternShader__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  float arg2 ;
+  StrokeShaders::ThicknessVariationPatternShader *result = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ThicknessVariationPatternShader",&obj0,&obj1)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ThicknessVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ThicknessVariationPatternShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::ThicknessVariationPatternShader *)new StrokeShaders::ThicknessVariationPatternShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessVariationPatternShader__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  StrokeShaders::ThicknessVariationPatternShader *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ThicknessVariationPatternShader",&obj0)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ThicknessVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    try {
+      result = (StrokeShaders::ThicknessVariationPatternShader *)new StrokeShaders::ThicknessVariationPatternShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessVariationPatternShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ThicknessVariationPatternShader__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ThicknessVariationPatternShader__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ThicknessVariationPatternShader__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_bool(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_ThicknessVariationPatternShader__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ThicknessVariationPatternShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ThicknessVariationPatternShader(std::string const,float,float,bool)\n    StrokeShaders::ThicknessVariationPatternShader(std::string const,float,float)\n    StrokeShaders::ThicknessVariationPatternShader(std::string const,float)\n    StrokeShaders::ThicknessVariationPatternShader(std::string const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ThicknessVariationPatternShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ThicknessVariationPatternShader *arg1 = (StrokeShaders::ThicknessVariationPatternShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ThicknessVariationPatternShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThicknessVariationPatternShader" "', argument " "1"" of type '" "StrokeShaders::ThicknessVariationPatternShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ThicknessVariationPatternShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ThicknessVariationPatternShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ThicknessVariationPatternShader *arg1 = (StrokeShaders::ThicknessVariationPatternShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ThicknessVariationPatternShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThicknessVariationPatternShader_shade" "', argument " "1"" of type '" "StrokeShaders::ThicknessVariationPatternShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ThicknessVariationPatternShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThicknessVariationPatternShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThicknessVariationPatternShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ThicknessVariationPatternShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ThicknessVariationPatternShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ThicknessVariationPatternShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ThicknessNoiseShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ThicknessNoiseShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ThicknessNoiseShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::ThicknessNoiseShader *)new StrokeShaders::ThicknessNoiseShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessNoiseShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  StrokeShaders::ThicknessNoiseShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ThicknessNoiseShader",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ThicknessNoiseShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ThicknessNoiseShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::ThicknessNoiseShader *)new StrokeShaders::ThicknessNoiseShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ThicknessNoiseShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ThicknessNoiseShader__SWIG_0(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ThicknessNoiseShader__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ThicknessNoiseShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ThicknessNoiseShader()\n    StrokeShaders::ThicknessNoiseShader(float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ThicknessNoiseShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ThicknessNoiseShader *arg1 = (StrokeShaders::ThicknessNoiseShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ThicknessNoiseShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThicknessNoiseShader_shade" "', argument " "1"" of type '" "StrokeShaders::ThicknessNoiseShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ThicknessNoiseShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThicknessNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThicknessNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ThicknessNoiseShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ThicknessNoiseShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ThicknessNoiseShader *arg1 = (StrokeShaders::ThicknessNoiseShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ThicknessNoiseShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThicknessNoiseShader" "', argument " "1"" of type '" "StrokeShaders::ThicknessNoiseShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ThicknessNoiseShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ThicknessNoiseShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ThicknessNoiseShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ConstantColorShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  StrokeShaders::ConstantColorShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantColorShader",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantColorShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantColorShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantColorShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantColorShader" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      result = (StrokeShaders::ConstantColorShader *)new StrokeShaders::ConstantColorShader(arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ConstantColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ConstantColorShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  StrokeShaders::ConstantColorShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ConstantColorShader",&obj0,&obj1,&obj2)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantColorShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantColorShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantColorShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      result = (StrokeShaders::ConstantColorShader *)new StrokeShaders::ConstantColorShader(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ConstantColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ConstantColorShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_ConstantColorShader__SWIG_1(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_ConstantColorShader__SWIG_0(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ConstantColorShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ConstantColorShader(float,float,float,float)\n    StrokeShaders::ConstantColorShader(float,float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantColorShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantColorShader *arg1 = (StrokeShaders::ConstantColorShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:ConstantColorShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantColorShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantColorShader_getName" "', argument " "1"" of type '" "StrokeShaders::ConstantColorShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantColorShader * >(argp1);
+  {
+    try {
+      result = ((StrokeShaders::ConstantColorShader const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ConstantColorShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantColorShader *arg1 = (StrokeShaders::ConstantColorShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ConstantColorShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantColorShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantColorShader_shade" "', argument " "1"" of type '" "StrokeShaders::ConstantColorShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantColorShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ConstantColorShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ConstantColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ConstantColorShader *arg1 = (StrokeShaders::ConstantColorShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstantColorShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ConstantColorShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantColorShader" "', argument " "1"" of type '" "StrokeShaders::ConstantColorShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ConstantColorShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ConstantColorShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ConstantColorShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_IncreasingColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  float arg5 ;
+  float arg6 ;
+  float arg7 ;
+  float arg8 ;
+  StrokeShaders::IncreasingColorShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  float val7 ;
+  int ecode7 = 0 ;
+  float val8 ;
+  int ecode8 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  PyObject * obj7 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_IncreasingColorShader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncreasingColorShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IncreasingColorShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IncreasingColorShader" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_IncreasingColorShader" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_IncreasingColorShader" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  ecode6 = SWIG_AsVal_float(obj5, &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IncreasingColorShader" "', argument " "6"" of type '" "float""'");
+  } 
+  arg6 = static_cast< float >(val6);
+  ecode7 = SWIG_AsVal_float(obj6, &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_IncreasingColorShader" "', argument " "7"" of type '" "float""'");
+  } 
+  arg7 = static_cast< float >(val7);
+  ecode8 = SWIG_AsVal_float(obj7, &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_IncreasingColorShader" "', argument " "8"" of type '" "float""'");
+  } 
+  arg8 = static_cast< float >(val8);
+  {
+    try {
+      result = (StrokeShaders::IncreasingColorShader *)new StrokeShaders::IncreasingColorShader(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__IncreasingColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_IncreasingColorShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::IncreasingColorShader *arg1 = (StrokeShaders::IncreasingColorShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:IncreasingColorShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__IncreasingColorShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncreasingColorShader_shade" "', argument " "1"" of type '" "StrokeShaders::IncreasingColorShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::IncreasingColorShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncreasingColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncreasingColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::IncreasingColorShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_IncreasingColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::IncreasingColorShader *arg1 = (StrokeShaders::IncreasingColorShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncreasingColorShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__IncreasingColorShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncreasingColorShader" "', argument " "1"" of type '" "StrokeShaders::IncreasingColorShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::IncreasingColorShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *IncreasingColorShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__IncreasingColorShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ColorVariationPatternShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  bool arg2 ;
+  StrokeShaders::ColorVariationPatternShader *result = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ColorVariationPatternShader",&obj0,&obj1)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ColorVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColorVariationPatternShader" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      result = (StrokeShaders::ColorVariationPatternShader *)new StrokeShaders::ColorVariationPatternShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ColorVariationPatternShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  StrokeShaders::ColorVariationPatternShader *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ColorVariationPatternShader",&obj0)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ColorVariationPatternShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    try {
+      result = (StrokeShaders::ColorVariationPatternShader *)new StrokeShaders::ColorVariationPatternShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ColorVariationPatternShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_ColorVariationPatternShader__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ColorVariationPatternShader__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ColorVariationPatternShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ColorVariationPatternShader(std::string const,bool)\n    StrokeShaders::ColorVariationPatternShader(std::string const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ColorVariationPatternShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ColorVariationPatternShader *arg1 = (StrokeShaders::ColorVariationPatternShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColorVariationPatternShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorVariationPatternShader" "', argument " "1"" of type '" "StrokeShaders::ColorVariationPatternShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ColorVariationPatternShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ColorVariationPatternShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ColorVariationPatternShader *arg1 = (StrokeShaders::ColorVariationPatternShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ColorVariationPatternShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorVariationPatternShader_shade" "', argument " "1"" of type '" "StrokeShaders::ColorVariationPatternShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ColorVariationPatternShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColorVariationPatternShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColorVariationPatternShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ColorVariationPatternShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ColorVariationPatternShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ColorVariationPatternShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_MaterialColorShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::MaterialColorShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_MaterialColorShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaterialColorShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::MaterialColorShader *)new StrokeShaders::MaterialColorShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__MaterialColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_MaterialColorShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::MaterialColorShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_MaterialColorShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::MaterialColorShader *)new StrokeShaders::MaterialColorShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__MaterialColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_MaterialColorShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_MaterialColorShader__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_MaterialColorShader__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_MaterialColorShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::MaterialColorShader(float)\n    StrokeShaders::MaterialColorShader()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_MaterialColorShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::MaterialColorShader *arg1 = (StrokeShaders::MaterialColorShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:MaterialColorShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__MaterialColorShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MaterialColorShader_shade" "', argument " "1"" of type '" "StrokeShaders::MaterialColorShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::MaterialColorShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MaterialColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MaterialColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::MaterialColorShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_MaterialColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::MaterialColorShader *arg1 = (StrokeShaders::MaterialColorShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaterialColorShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__MaterialColorShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaterialColorShader" "', argument " "1"" of type '" "StrokeShaders::MaterialColorShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::MaterialColorShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *MaterialColorShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__MaterialColorShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_CalligraphicColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Geometry::Vec2d *arg1 = 0 ;
+  StrokeShaders::CalligraphicColorShader *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_CalligraphicColorShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_VecMat__Vec2Tdouble_t,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalligraphicColorShader" "', argument " "1"" of type '" "Geometry::Vec2d const &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalligraphicColorShader" "', argument " "1"" of type '" "Geometry::Vec2d const &""'"); 
+  }
+  arg1 = reinterpret_cast< Geometry::Vec2d * >(argp1);
+  {
+    try {
+      result = (StrokeShaders::CalligraphicColorShader *)new StrokeShaders::CalligraphicColorShader((Geometry::Vec2d const &)*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__CalligraphicColorShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CalligraphicColorShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::CalligraphicColorShader *arg1 = (StrokeShaders::CalligraphicColorShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CalligraphicColorShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__CalligraphicColorShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalligraphicColorShader_shade" "', argument " "1"" of type '" "StrokeShaders::CalligraphicColorShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::CalligraphicColorShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalligraphicColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalligraphicColorShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::CalligraphicColorShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CalligraphicColorShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::CalligraphicColorShader *arg1 = (StrokeShaders::CalligraphicColorShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CalligraphicColorShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__CalligraphicColorShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalligraphicColorShader" "', argument " "1"" of type '" "StrokeShaders::CalligraphicColorShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::CalligraphicColorShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CalligraphicColorShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__CalligraphicColorShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ColorNoiseShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ColorNoiseShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ColorNoiseShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::ColorNoiseShader *)new StrokeShaders::ColorNoiseShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ColorNoiseShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ColorNoiseShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  StrokeShaders::ColorNoiseShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_ColorNoiseShader",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColorNoiseShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColorNoiseShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::ColorNoiseShader *)new StrokeShaders::ColorNoiseShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ColorNoiseShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ColorNoiseShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ColorNoiseShader__SWIG_0(self, args);
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_ColorNoiseShader__SWIG_1(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ColorNoiseShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ColorNoiseShader()\n    StrokeShaders::ColorNoiseShader(float,float)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ColorNoiseShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ColorNoiseShader *arg1 = (StrokeShaders::ColorNoiseShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ColorNoiseShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ColorNoiseShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorNoiseShader_shade" "', argument " "1"" of type '" "StrokeShaders::ColorNoiseShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ColorNoiseShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColorNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColorNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ColorNoiseShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ColorNoiseShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ColorNoiseShader *arg1 = (StrokeShaders::ColorNoiseShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColorNoiseShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ColorNoiseShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorNoiseShader" "', argument " "1"" of type '" "StrokeShaders::ColorNoiseShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ColorNoiseShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ColorNoiseShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ColorNoiseShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_TextureAssignerShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  StrokeShaders::TextureAssignerShader *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_TextureAssignerShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TextureAssignerShader" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  {
+    try {
+      result = (StrokeShaders::TextureAssignerShader *)new StrokeShaders::TextureAssignerShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__TextureAssignerShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TextureAssignerShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::TextureAssignerShader *arg1 = (StrokeShaders::TextureAssignerShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TextureAssignerShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__TextureAssignerShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextureAssignerShader_shade" "', argument " "1"" of type '" "StrokeShaders::TextureAssignerShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::TextureAssignerShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextureAssignerShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextureAssignerShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::TextureAssignerShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TextureAssignerShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::TextureAssignerShader *arg1 = (StrokeShaders::TextureAssignerShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TextureAssignerShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__TextureAssignerShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TextureAssignerShader" "', argument " "1"" of type '" "StrokeShaders::TextureAssignerShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::TextureAssignerShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TextureAssignerShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__TextureAssignerShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_StrokeTextureShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  Stroke::MediumType arg2 ;
+  bool arg3 ;
+  StrokeShaders::StrokeTextureShader *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_StrokeTextureShader",&obj0,&obj1,&obj2)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_StrokeTextureShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StrokeTextureShader" "', argument " "2"" of type '" "Stroke::MediumType""'");
+  } 
+  arg2 = static_cast< Stroke::MediumType >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StrokeTextureShader" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      result = (StrokeShaders::StrokeTextureShader *)new StrokeShaders::StrokeTextureShader(arg1,arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__StrokeTextureShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeTextureShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  Stroke::MediumType arg2 ;
+  StrokeShaders::StrokeTextureShader *result = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_StrokeTextureShader",&obj0,&obj1)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_StrokeTextureShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StrokeTextureShader" "', argument " "2"" of type '" "Stroke::MediumType""'");
+  } 
+  arg2 = static_cast< Stroke::MediumType >(val2);
+  {
+    try {
+      result = (StrokeShaders::StrokeTextureShader *)new StrokeShaders::StrokeTextureShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__StrokeTextureShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeTextureShader__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string arg1 ;
+  StrokeShaders::StrokeTextureShader *result = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_StrokeTextureShader",&obj0)) SWIG_fail;
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(obj0, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_StrokeTextureShader" "', argument " "1"" of type '" "std::string const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    try {
+      result = (StrokeShaders::StrokeTextureShader *)new StrokeShaders::StrokeTextureShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__StrokeTextureShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_StrokeTextureShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_StrokeTextureShader__SWIG_2(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_StrokeTextureShader__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_bool(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_StrokeTextureShader__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_StrokeTextureShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::StrokeTextureShader(std::string const,Stroke::MediumType,bool)\n    StrokeShaders::StrokeTextureShader(std::string const,Stroke::MediumType)\n    StrokeShaders::StrokeTextureShader(std::string const)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_StrokeTextureShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::StrokeTextureShader *arg1 = (StrokeShaders::StrokeTextureShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:StrokeTextureShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__StrokeTextureShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StrokeTextureShader_shade" "', argument " "1"" of type '" "StrokeShaders::StrokeTextureShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::StrokeTextureShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StrokeTextureShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StrokeTextureShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::StrokeTextureShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_StrokeTextureShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::StrokeTextureShader *arg1 = (StrokeShaders::StrokeTextureShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrokeTextureShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__StrokeTextureShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrokeTextureShader" "', argument " "1"" of type '" "StrokeShaders::StrokeTextureShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::StrokeTextureShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *StrokeTextureShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__StrokeTextureShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_BackboneStretcherShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::BackboneStretcherShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_BackboneStretcherShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BackboneStretcherShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::BackboneStretcherShader *)new StrokeShaders::BackboneStretcherShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__BackboneStretcherShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_BackboneStretcherShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BackboneStretcherShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_BackboneStretcherShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::BackboneStretcherShader *)new StrokeShaders::BackboneStretcherShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__BackboneStretcherShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_BackboneStretcherShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_BackboneStretcherShader__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_BackboneStretcherShader__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BackboneStretcherShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::BackboneStretcherShader(float)\n    StrokeShaders::BackboneStretcherShader()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BackboneStretcherShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BackboneStretcherShader *arg1 = (StrokeShaders::BackboneStretcherShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:BackboneStretcherShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BackboneStretcherShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackboneStretcherShader_shade" "', argument " "1"" of type '" "StrokeShaders::BackboneStretcherShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BackboneStretcherShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackboneStretcherShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackboneStretcherShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::BackboneStretcherShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_BackboneStretcherShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BackboneStretcherShader *arg1 = (StrokeShaders::BackboneStretcherShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_BackboneStretcherShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BackboneStretcherShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackboneStretcherShader" "', argument " "1"" of type '" "StrokeShaders::BackboneStretcherShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BackboneStretcherShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *BackboneStretcherShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__BackboneStretcherShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_SamplingShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::SamplingShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_SamplingShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SamplingShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::SamplingShader *)new StrokeShaders::SamplingShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__SamplingShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SamplingShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::SamplingShader *arg1 = (StrokeShaders::SamplingShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SamplingShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__SamplingShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SamplingShader_shade" "', argument " "1"" of type '" "StrokeShaders::SamplingShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::SamplingShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SamplingShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SamplingShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::SamplingShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SamplingShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::SamplingShader *arg1 = (StrokeShaders::SamplingShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SamplingShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__SamplingShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SamplingShader" "', argument " "1"" of type '" "StrokeShaders::SamplingShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::SamplingShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SamplingShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__SamplingShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_ExternalContourStretcherShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::ExternalContourStretcherShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_ExternalContourStretcherShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExternalContourStretcherShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::ExternalContourStretcherShader *)new StrokeShaders::ExternalContourStretcherShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ExternalContourStretcherShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ExternalContourStretcherShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ExternalContourStretcherShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::ExternalContourStretcherShader *)new StrokeShaders::ExternalContourStretcherShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ExternalContourStretcherShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_ExternalContourStretcherShader__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_ExternalContourStretcherShader__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ExternalContourStretcherShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::ExternalContourStretcherShader(float)\n    StrokeShaders::ExternalContourStretcherShader()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_ExternalContourStretcherShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ExternalContourStretcherShader *arg1 = (StrokeShaders::ExternalContourStretcherShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:ExternalContourStretcherShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalContourStretcherShader_shade" "', argument " "1"" of type '" "StrokeShaders::ExternalContourStretcherShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ExternalContourStretcherShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExternalContourStretcherShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExternalContourStretcherShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::ExternalContourStretcherShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ExternalContourStretcherShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::ExternalContourStretcherShader *arg1 = (StrokeShaders::ExternalContourStretcherShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExternalContourStretcherShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExternalContourStretcherShader" "', argument " "1"" of type '" "StrokeShaders::ExternalContourStretcherShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::ExternalContourStretcherShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ExternalContourStretcherShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__ExternalContourStretcherShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_BSplineShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BSplineShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_BSplineShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::BSplineShader *)new StrokeShaders::BSplineShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__BSplineShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BSplineShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BSplineShader *arg1 = (StrokeShaders::BSplineShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:BSplineShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BSplineShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BSplineShader_shade" "', argument " "1"" of type '" "StrokeShaders::BSplineShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BSplineShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BSplineShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BSplineShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::BSplineShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_BSplineShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BSplineShader *arg1 = (StrokeShaders::BSplineShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_BSplineShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BSplineShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BSplineShader" "', argument " "1"" of type '" "StrokeShaders::BSplineShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BSplineShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *BSplineShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__BSplineShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_BezierCurveShader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::BezierCurveShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_BezierCurveShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BezierCurveShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::BezierCurveShader *)new StrokeShaders::BezierCurveShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__BezierCurveShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_BezierCurveShader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BezierCurveShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_BezierCurveShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::BezierCurveShader *)new StrokeShaders::BezierCurveShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__BezierCurveShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_BezierCurveShader(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_BezierCurveShader__SWIG_1(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_BezierCurveShader__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_BezierCurveShader'.\n  Possible C/C++ prototypes are:\n    StrokeShaders::BezierCurveShader(float)\n    StrokeShaders::BezierCurveShader()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_BezierCurveShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BezierCurveShader *arg1 = (StrokeShaders::BezierCurveShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:BezierCurveShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BezierCurveShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BezierCurveShader_shade" "', argument " "1"" of type '" "StrokeShaders::BezierCurveShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BezierCurveShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BezierCurveShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BezierCurveShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::BezierCurveShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_BezierCurveShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::BezierCurveShader *arg1 = (StrokeShaders::BezierCurveShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_BezierCurveShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__BezierCurveShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BezierCurveShader" "', argument " "1"" of type '" "StrokeShaders::BezierCurveShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::BezierCurveShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *BezierCurveShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__BezierCurveShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_InflateShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  StrokeShaders::InflateShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_InflateShader",&obj0,&obj1)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InflateShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InflateShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      result = (StrokeShaders::InflateShader *)new StrokeShaders::InflateShader(arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__InflateShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_InflateShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::InflateShader *arg1 = (StrokeShaders::InflateShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:InflateShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__InflateShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InflateShader_shade" "', argument " "1"" of type '" "StrokeShaders::InflateShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::InflateShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InflateShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InflateShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::InflateShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_InflateShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::InflateShader *arg1 = (StrokeShaders::InflateShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_InflateShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__InflateShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InflateShader" "', argument " "1"" of type '" "StrokeShaders::InflateShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::InflateShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *InflateShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__InflateShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_PolygonalizationShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::PolygonalizationShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_PolygonalizationShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PolygonalizationShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::PolygonalizationShader *)new StrokeShaders::PolygonalizationShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__PolygonalizationShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_PolygonalizationShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::PolygonalizationShader *arg1 = (StrokeShaders::PolygonalizationShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:PolygonalizationShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__PolygonalizationShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolygonalizationShader_shade" "', argument " "1"" of type '" "StrokeShaders::PolygonalizationShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::PolygonalizationShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PolygonalizationShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolygonalizationShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::PolygonalizationShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_PolygonalizationShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::PolygonalizationShader *arg1 = (StrokeShaders::PolygonalizationShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_PolygonalizationShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__PolygonalizationShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PolygonalizationShader" "', argument " "1"" of type '" "StrokeShaders::PolygonalizationShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::PolygonalizationShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *PolygonalizationShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__PolygonalizationShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_GuidingLinesShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  StrokeShaders::GuidingLinesShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_GuidingLinesShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GuidingLinesShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  {
+    try {
+      result = (StrokeShaders::GuidingLinesShader *)new StrokeShaders::GuidingLinesShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__GuidingLinesShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_GuidingLinesShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::GuidingLinesShader *arg1 = (StrokeShaders::GuidingLinesShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:GuidingLinesShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__GuidingLinesShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GuidingLinesShader_shade" "', argument " "1"" of type '" "StrokeShaders::GuidingLinesShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::GuidingLinesShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GuidingLinesShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GuidingLinesShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::GuidingLinesShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_GuidingLinesShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::GuidingLinesShader *arg1 = (StrokeShaders::GuidingLinesShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_GuidingLinesShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__GuidingLinesShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GuidingLinesShader" "', argument " "1"" of type '" "StrokeShaders::GuidingLinesShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::GuidingLinesShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *GuidingLinesShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__GuidingLinesShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_TipRemoverShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  StrokeShaders::TipRemoverShader *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_TipRemoverShader",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TipRemoverShader" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  {
+    try {
+      result = (StrokeShaders::TipRemoverShader *)new StrokeShaders::TipRemoverShader(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__TipRemoverShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_TipRemoverShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::TipRemoverShader *arg1 = (StrokeShaders::TipRemoverShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_TipRemoverShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__TipRemoverShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipRemoverShader" "', argument " "1"" of type '" "StrokeShaders::TipRemoverShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::TipRemoverShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_TipRemoverShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::TipRemoverShader *arg1 = (StrokeShaders::TipRemoverShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:TipRemoverShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__TipRemoverShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipRemoverShader_shade" "', argument " "1"" of type '" "StrokeShaders::TipRemoverShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::TipRemoverShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TipRemoverShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TipRemoverShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::TipRemoverShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *TipRemoverShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__TipRemoverShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_delete_streamShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::streamShader *arg1 = (StrokeShaders::streamShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_streamShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__streamShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_streamShader" "', argument " "1"" of type '" "StrokeShaders::streamShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::streamShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_streamShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::streamShader *arg1 = (StrokeShaders::streamShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:streamShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__streamShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamShader_getName" "', argument " "1"" of type '" "StrokeShaders::streamShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::streamShader * >(argp1);
+  {
+    try {
+      result = ((StrokeShaders::streamShader const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_streamShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::streamShader *arg1 = (StrokeShaders::streamShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:streamShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__streamShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamShader_shade" "', argument " "1"" of type '" "StrokeShaders::streamShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::streamShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streamShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::streamShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_streamShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::streamShader *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_streamShader")) SWIG_fail;
+  {
+    try {
+      result = (StrokeShaders::streamShader *)new StrokeShaders::streamShader();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__streamShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *streamShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__streamShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_fstreamShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  StrokeShaders::fstreamShader *result = 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_fstreamShader",&obj0)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_fstreamShader" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  {
+    try {
+      result = (StrokeShaders::fstreamShader *)new StrokeShaders::fstreamShader((char const *)arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeShaders__fstreamShader, SWIG_POINTER_NEW |  0 );
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_fstreamShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::fstreamShader *arg1 = (StrokeShaders::fstreamShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_fstreamShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__fstreamShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fstreamShader" "', argument " "1"" of type '" "StrokeShaders::fstreamShader *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::fstreamShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_fstreamShader_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::fstreamShader *arg1 = (StrokeShaders::fstreamShader *) 0 ;
+  std::string result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:fstreamShader_getName",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__fstreamShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fstreamShader_getName" "', argument " "1"" of type '" "StrokeShaders::fstreamShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::fstreamShader * >(argp1);
+  {
+    try {
+      result = ((StrokeShaders::fstreamShader const *)arg1)->getName();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_fstreamShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  StrokeShaders::fstreamShader *arg1 = (StrokeShaders::fstreamShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:fstreamShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_StrokeShaders__fstreamShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fstreamShader_shade" "', argument " "1"" of type '" "StrokeShaders::fstreamShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< StrokeShaders::fstreamShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fstreamShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fstreamShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((StrokeShaders::fstreamShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *fstreamShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_StrokeShaders__fstreamShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_CalligraphicShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  real arg2 ;
+  Geometry::Vec2f *arg3 = 0 ;
+  bool arg4 ;
+  CalligraphicShader *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CalligraphicShader",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CalligraphicShader" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CalligraphicShader" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CalligraphicShader" "', argument " "3"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalligraphicShader" "', argument " "3"" of type '" "Geometry::Vec2f const &""'"); 
+  }
+  arg3 = reinterpret_cast< Geometry::Vec2f * >(argp3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CalligraphicShader" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  {
+    try {
+      result = (CalligraphicShader *)new CalligraphicShader(arg1,arg2,(Geometry::Vec2f const &)*arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CalligraphicShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_CalligraphicShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CalligraphicShader *arg1 = (CalligraphicShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_CalligraphicShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CalligraphicShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalligraphicShader" "', argument " "1"" of type '" "CalligraphicShader *""'"); 
+  }
+  arg1 = reinterpret_cast< CalligraphicShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_CalligraphicShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  CalligraphicShader *arg1 = (CalligraphicShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:CalligraphicShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CalligraphicShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalligraphicShader_shade" "', argument " "1"" of type '" "CalligraphicShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< CalligraphicShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalligraphicShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalligraphicShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((CalligraphicShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *CalligraphicShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_CalligraphicShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_SpatialNoiseShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  float arg1 ;
+  float arg2 ;
+  int arg3 ;
+  bool arg4 ;
+  bool arg5 ;
+  SpatialNoiseShader *result = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SpatialNoiseShader",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  ecode1 = SWIG_AsVal_float(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpatialNoiseShader" "', argument " "1"" of type '" "float""'");
+  } 
+  arg1 = static_cast< float >(val1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpatialNoiseShader" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpatialNoiseShader" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_bool(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpatialNoiseShader" "', argument " "4"" of type '" "bool""'");
+  } 
+  arg4 = static_cast< bool >(val4);
+  ecode5 = SWIG_AsVal_bool(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpatialNoiseShader" "', argument " "5"" of type '" "bool""'");
+  } 
+  arg5 = static_cast< bool >(val5);
+  {
+    try {
+      result = (SpatialNoiseShader *)new SpatialNoiseShader(arg1,arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SpatialNoiseShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SpatialNoiseShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SpatialNoiseShader *arg1 = (SpatialNoiseShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SpatialNoiseShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpatialNoiseShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialNoiseShader" "', argument " "1"" of type '" "SpatialNoiseShader *""'"); 
+  }
+  arg1 = reinterpret_cast< SpatialNoiseShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SpatialNoiseShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SpatialNoiseShader *arg1 = (SpatialNoiseShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SpatialNoiseShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SpatialNoiseShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialNoiseShader_shade" "', argument " "1"" of type '" "SpatialNoiseShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< SpatialNoiseShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialNoiseShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((SpatialNoiseShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SpatialNoiseShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_SpatialNoiseShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_SmoothingShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  int arg1 ;
+  real arg2 ;
+  real arg3 ;
+  real arg4 ;
+  real arg5 ;
+  real arg6 ;
+  real arg7 ;
+  real arg8 ;
+  SmoothingShader *result = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  PyObject * obj7 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_SmoothingShader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
+  ecode1 = SWIG_AsVal_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SmoothingShader" "', argument " "1"" of type '" "int""'");
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SmoothingShader" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SmoothingShader" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  ecode4 = SWIG_AsVal_double(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SmoothingShader" "', argument " "4"" of type '" "real""'");
+  } 
+  arg4 = static_cast< real >(val4);
+  ecode5 = SWIG_AsVal_double(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SmoothingShader" "', argument " "5"" of type '" "real""'");
+  } 
+  arg5 = static_cast< real >(val5);
+  ecode6 = SWIG_AsVal_double(obj5, &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SmoothingShader" "', argument " "6"" of type '" "real""'");
+  } 
+  arg6 = static_cast< real >(val6);
+  ecode7 = SWIG_AsVal_double(obj6, &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SmoothingShader" "', argument " "7"" of type '" "real""'");
+  } 
+  arg7 = static_cast< real >(val7);
+  ecode8 = SWIG_AsVal_double(obj7, &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SmoothingShader" "', argument " "8"" of type '" "real""'");
+  } 
+  arg8 = static_cast< real >(val8);
+  {
+    try {
+      result = (SmoothingShader *)new SmoothingShader(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SmoothingShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_SmoothingShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SmoothingShader *arg1 = (SmoothingShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_SmoothingShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SmoothingShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SmoothingShader" "', argument " "1"" of type '" "SmoothingShader *""'"); 
+  }
+  arg1 = reinterpret_cast< SmoothingShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_SmoothingShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  SmoothingShader *arg1 = (SmoothingShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:SmoothingShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SmoothingShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SmoothingShader_shade" "', argument " "1"" of type '" "SmoothingShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< SmoothingShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SmoothingShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SmoothingShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((SmoothingShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *SmoothingShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_SmoothingShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Smoother(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = 0 ;
+  Smoother *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Smoother",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Smoother" "', argument " "1"" of type '" "Stroke &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Smoother" "', argument " "1"" of type '" "Stroke &""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (Smoother *)new Smoother(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Smoother, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Smoother(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Smoother *arg1 = (Smoother *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Smoother",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Smoother, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Smoother" "', argument " "1"" of type '" "Smoother *""'"); 
+  }
+  arg1 = reinterpret_cast< Smoother * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Smoother_smooth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Smoother *arg1 = (Smoother *) 0 ;
+  int arg2 ;
+  real arg3 ;
+  real arg4 ;
+  real arg5 ;
+  real arg6 ;
+  real arg7 ;
+  real arg8 ;
+  real arg9 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val9 ;
+  int ecode9 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  PyObject * obj6 = 0 ;
+  PyObject * obj7 = 0 ;
+  PyObject * obj8 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Smoother_smooth",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Smoother, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Smoother_smooth" "', argument " "1"" of type '" "Smoother *""'"); 
+  }
+  arg1 = reinterpret_cast< Smoother * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Smoother_smooth" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Smoother_smooth" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  ecode4 = SWIG_AsVal_double(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Smoother_smooth" "', argument " "4"" of type '" "real""'");
+  } 
+  arg4 = static_cast< real >(val4);
+  ecode5 = SWIG_AsVal_double(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Smoother_smooth" "', argument " "5"" of type '" "real""'");
+  } 
+  arg5 = static_cast< real >(val5);
+  ecode6 = SWIG_AsVal_double(obj5, &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Smoother_smooth" "', argument " "6"" of type '" "real""'");
+  } 
+  arg6 = static_cast< real >(val6);
+  ecode7 = SWIG_AsVal_double(obj6, &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Smoother_smooth" "', argument " "7"" of type '" "real""'");
+  } 
+  arg7 = static_cast< real >(val7);
+  ecode8 = SWIG_AsVal_double(obj7, &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Smoother_smooth" "', argument " "8"" of type '" "real""'");
+  } 
+  arg8 = static_cast< real >(val8);
+  ecode9 = SWIG_AsVal_double(obj8, &val9);
+  if (!SWIG_IsOK(ecode9)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Smoother_smooth" "', argument " "9"" of type '" "real""'");
+  } 
+  arg9 = static_cast< real >(val9);
+  {
+    try {
+      (arg1)->smooth(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Smoother_computeCurvature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Smoother *arg1 = (Smoother *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Smoother_computeCurvature",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Smoother, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Smoother_computeCurvature" "', argument " "1"" of type '" "Smoother *""'"); 
+  }
+  arg1 = reinterpret_cast< Smoother * >(argp1);
+  {
+    try {
+      (arg1)->computeCurvature();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Smoother_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Smoother, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_Omitter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Stroke *arg1 = 0 ;
+  Omitter *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_Omitter",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Omitter" "', argument " "1"" of type '" "Stroke &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Omitter" "', argument " "1"" of type '" "Stroke &""'"); 
+  }
+  arg1 = reinterpret_cast< Stroke * >(argp1);
+  {
+    try {
+      result = (Omitter *)new Omitter(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Omitter, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Omitter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Omitter *arg1 = (Omitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Omitter",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Omitter, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Omitter" "', argument " "1"" of type '" "Omitter *""'"); 
+  }
+  arg1 = reinterpret_cast< Omitter * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Omitter_omit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Omitter *arg1 = (Omitter *) 0 ;
+  real arg2 ;
+  real arg3 ;
+  real arg4 ;
+  real arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Omitter_omit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Omitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Omitter_omit" "', argument " "1"" of type '" "Omitter *""'"); 
+  }
+  arg1 = reinterpret_cast< Omitter * >(argp1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Omitter_omit" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Omitter_omit" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  ecode4 = SWIG_AsVal_double(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Omitter_omit" "', argument " "4"" of type '" "real""'");
+  } 
+  arg4 = static_cast< real >(val4);
+  ecode5 = SWIG_AsVal_double(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Omitter_omit" "', argument " "5"" of type '" "real""'");
+  } 
+  arg5 = static_cast< real >(val5);
+  {
+    try {
+      (arg1)->omit(arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Omitter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Omitter, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_OmissionShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  real arg1 ;
+  real arg2 ;
+  real arg3 ;
+  real arg4 ;
+  OmissionShader *result = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_OmissionShader",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  ecode1 = SWIG_AsVal_double(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OmissionShader" "', argument " "1"" of type '" "real""'");
+  } 
+  arg1 = static_cast< real >(val1);
+  ecode2 = SWIG_AsVal_double(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OmissionShader" "', argument " "2"" of type '" "real""'");
+  } 
+  arg2 = static_cast< real >(val2);
+  ecode3 = SWIG_AsVal_double(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OmissionShader" "', argument " "3"" of type '" "real""'");
+  } 
+  arg3 = static_cast< real >(val3);
+  ecode4 = SWIG_AsVal_double(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OmissionShader" "', argument " "4"" of type '" "real""'");
+  } 
+  arg4 = static_cast< real >(val4);
+  {
+    try {
+      result = (OmissionShader *)new OmissionShader(arg1,arg2,arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_OmissionShader, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_OmissionShader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  OmissionShader *arg1 = (OmissionShader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_OmissionShader",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OmissionShader, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OmissionShader" "', argument " "1"" of type '" "OmissionShader *""'"); 
+  }
+  arg1 = reinterpret_cast< OmissionShader * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_OmissionShader_shade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  OmissionShader *arg1 = (OmissionShader *) 0 ;
+  Stroke *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:OmissionShader_shade",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_OmissionShader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OmissionShader_shade" "', argument " "1"" of type '" "OmissionShader const *""'"); 
+  }
+  arg1 = reinterpret_cast< OmissionShader * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Stroke,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OmissionShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OmissionShader_shade" "', argument " "2"" of type '" "Stroke &""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      ((OmissionShader const *)arg1)->shade(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *OmissionShader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_OmissionShader, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Operators_select(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_select",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_select" "', argument " "1"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_select" "', argument " "1"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  {
+    try {
+      Operators::select(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_chain__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  UnaryFunction1D<void > *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Operators_chain",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_chain" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_chain" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_chain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_chain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UnaryFunction1DTvoid_t,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operators_chain" "', argument " "3"" of type '" "UnaryFunction1D<void > &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_chain" "', argument " "3"" of type '" "UnaryFunction1D<void > &""'"); 
+  }
+  arg3 = reinterpret_cast< UnaryFunction1D<void > * >(argp3);
+  {
+    try {
+      Operators::chain(*arg1,*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_chain__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ViewEdgeInternal::ViewEdgeIterator *arg1 = 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_chain",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_chain" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_chain" "', argument " "1"" of type '" "ViewEdgeInternal::ViewEdgeIterator &""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::ViewEdgeIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_chain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_chain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  {
+    try {
+      Operators::chain(*arg1,*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_chain(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Operators_chain__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ViewEdgeInternal__ViewEdgeIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UnaryFunction1DTvoid_t, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Operators_chain__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Operators_chain'.\n  Possible C/C++ prototypes are:\n    chain(ViewEdgeInternal::ViewEdgeIterator &,UnaryPredicate1D &,UnaryFunction1D<void > &)\n    Operators::chain(ViewEdgeInternal::ViewEdgeIterator &,UnaryPredicate1D &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_bidirectionalChain__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_bidirectionalChain",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ChainingIterator,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_bidirectionalChain" "', argument " "1"" of type '" "ChainingIterator &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_bidirectionalChain" "', argument " "1"" of type '" "ChainingIterator &""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_bidirectionalChain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_bidirectionalChain" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  {
+    try {
+      Operators::bidirectionalChain(*arg1,*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_bidirectionalChain__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ChainingIterator *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_bidirectionalChain",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ChainingIterator,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_bidirectionalChain" "', argument " "1"" of type '" "ChainingIterator &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_bidirectionalChain" "', argument " "1"" of type '" "ChainingIterator &""'"); 
+  }
+  arg1 = reinterpret_cast< ChainingIterator * >(argp1);
+  {
+    try {
+      Operators::bidirectionalChain(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_bidirectionalChain(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ChainingIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Operators_bidirectionalChain__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_ChainingIterator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Operators_bidirectionalChain__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Operators_bidirectionalChain'.\n  Possible C/C++ prototypes are:\n    bidirectionalChain(ChainingIterator &,UnaryPredicate1D &)\n    Operators::bidirectionalChain(ChainingIterator &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sequentialSplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = 0 ;
+  UnaryPredicate0D *arg2 = 0 ;
+  float arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Operators_sequentialSplit",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_sequentialSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate0D * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Operators_sequentialSplit" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      Operators::sequentialSplit(*arg1,*arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sequentialSplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = 0 ;
+  UnaryPredicate0D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_sequentialSplit",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_sequentialSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate0D * >(argp2);
+  {
+    try {
+      Operators::sequentialSplit(*arg1,*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sequentialSplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = 0 ;
+  float arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_sequentialSplit",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  ecode2 = SWIG_AsVal_float(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Operators_sequentialSplit" "', argument " "2"" of type '" "float""'");
+  } 
+  arg2 = static_cast< float >(val2);
+  {
+    try {
+      Operators::sequentialSplit(*arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sequentialSplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate0D *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_sequentialSplit",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sequentialSplit" "', argument " "1"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate0D * >(argp1);
+  {
+    try {
+      Operators::sequentialSplit(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sequentialSplit(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Operators_sequentialSplit__SWIG_3(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Operators_sequentialSplit__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Operators_sequentialSplit__SWIG_2(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Operators_sequentialSplit__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Operators_sequentialSplit'.\n  Possible C/C++ prototypes are:\n    sequentialSplit(UnaryPredicate0D &,UnaryPredicate0D &,float)\n    sequentialSplit(UnaryPredicate0D &,UnaryPredicate0D &)\n    sequentialSplit(UnaryPredicate0D &,float)\n    Operators::sequentialSplit(UnaryPredicate0D &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_recursiveSplit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  float arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Operators_recursiveSplit",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  ecode3 = SWIG_AsVal_float(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Operators_recursiveSplit" "', argument " "3"" of type '" "float""'");
+  } 
+  arg3 = static_cast< float >(val3);
+  {
+    try {
+      Operators::recursiveSplit(*arg1,*arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_recursiveSplit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  UnaryPredicate1D *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_recursiveSplit",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate1D * >(argp2);
+  {
+    try {
+      Operators::recursiveSplit(*arg1,*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_recursiveSplit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  UnaryPredicate0D *arg2 = 0 ;
+  UnaryPredicate1D *arg3 = 0 ;
+  float arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:Operators_recursiveSplit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate0D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operators_recursiveSplit" "', argument " "3"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "3"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< UnaryPredicate1D * >(argp3);
+  ecode4 = SWIG_AsVal_float(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Operators_recursiveSplit" "', argument " "4"" of type '" "float""'");
+  } 
+  arg4 = static_cast< float >(val4);
+  {
+    try {
+      Operators::recursiveSplit(*arg1,*arg2,*arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_recursiveSplit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryFunction0D<double > *arg1 = 0 ;
+  UnaryPredicate0D *arg2 = 0 ;
+  UnaryPredicate1D *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Operators_recursiveSplit",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryFunction0DTdouble_t,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "1"" of type '" "UnaryFunction0D<double > &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryFunction0D<double > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UnaryPredicate0D,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "2"" of type '" "UnaryPredicate0D &""'"); 
+  }
+  arg2 = reinterpret_cast< UnaryPredicate0D * >(argp2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operators_recursiveSplit" "', argument " "3"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_recursiveSplit" "', argument " "3"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg3 = reinterpret_cast< UnaryPredicate1D * >(argp3);
+  {
+    try {
+      Operators::recursiveSplit(*arg1,*arg2,*arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_recursiveSplit(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 4); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Operators_recursiveSplit__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Operators_recursiveSplit__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Operators_recursiveSplit__SWIG_3(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_UnaryFunction0DTdouble_t, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_UnaryPredicate0D, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_UnaryPredicate1D, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Operators_recursiveSplit__SWIG_2(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Operators_recursiveSplit'.\n  Possible C/C++ prototypes are:\n    recursiveSplit(UnaryFunction0D<double > &,UnaryPredicate1D &,float)\n    recursiveSplit(UnaryFunction0D<double > &,UnaryPredicate1D &)\n    recursiveSplit(UnaryFunction0D<double > &,UnaryPredicate0D &,UnaryPredicate1D &,float)\n    Operators::recursiveSplit(UnaryFunction0D<double > &,UnaryPredicate0D &,UnaryPredicate1D &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  BinaryPredicate1D *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_sort",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_BinaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_sort" "', argument " "1"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_sort" "', argument " "1"" of type '" "BinaryPredicate1D &""'"); 
+  }
+  arg1 = reinterpret_cast< BinaryPredicate1D * >(argp1);
+  {
+    try {
+      Operators::sort(*arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UnaryPredicate1D *arg1 = 0 ;
+  std::vector<StrokeShader * > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Operators_create",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_UnaryPredicate1D,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operators_create" "', argument " "1"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operators_create" "', argument " "1"" of type '" "UnaryPredicate1D &""'"); 
+  }
+  arg1 = reinterpret_cast< UnaryPredicate1D * >(argp1);
+  {
+    std::vector<StrokeShader*,std::allocator<StrokeShader * > > *ptr = (std::vector<StrokeShader*,std::allocator<StrokeShader * > > *)0;
+    int res = swig::asptr(obj1, &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Operators_create" "', argument " "2"" of type '" "std::vector<StrokeShader * >""'"); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    try {
+      Operators::create(*arg1,arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getViewEdgeFromIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  ViewEdge *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_getViewEdgeFromIndex",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Operators_getViewEdgeFromIndex" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (ViewEdge *)Operators::getViewEdgeFromIndex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getChainFromIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Chain *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_getChainFromIndex",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Operators_getChainFromIndex" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Chain *)Operators::getChainFromIndex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Chain, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getStrokeFromIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int arg1 ;
+  Stroke *result = 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Operators_getStrokeFromIndex",&obj0)) SWIG_fail;
+  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Operators_getStrokeFromIndex" "', argument " "1"" of type '" "unsigned int""'");
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  {
+    try {
+      result = (Stroke *)Operators::getStrokeFromIndex(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Stroke, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getViewEdgesSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Operators_getViewEdgesSize")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)Operators::getViewEdgesSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getChainsSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Operators_getChainsSize")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)Operators::getChainsSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Operators_getStrokesSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  unsigned int result;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Operators_getStrokesSize")) SWIG_fail;
+  {
+    try {
+      result = (unsigned int)Operators::getStrokesSize();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Operators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Operators *arg1 = (Operators *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Operators",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Operators, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Operators" "', argument " "1"" of type '" "Operators *""'"); 
+  }
+  arg1 = reinterpret_cast< Operators * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Operators_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Operators, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_ltstr___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ltstr *arg1 = (ltstr *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:ltstr___call__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ltstr, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ltstr___call__" "', argument " "1"" of type '" "ltstr const *""'"); 
+  }
+  arg1 = reinterpret_cast< ltstr * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltstr___call__" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ltstr___call__" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    try {
+      result = (bool)((ltstr const *)arg1)->operator ()((char const *)arg2,(char const *)arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_ltstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ltstr *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":new_ltstr")) SWIG_fail;
+  {
+    try {
+      result = (ltstr *)new ltstr();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ltstr, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_ltstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  ltstr *arg1 = (ltstr *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_ltstr",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ltstr, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ltstr" "', argument " "1"" of type '" "ltstr *""'"); 
+  }
+  arg1 = reinterpret_cast< ltstr * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *ltstr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_ltstr, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_Canvas_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)":Canvas_getInstance")) SWIG_fail;
+  {
+    try {
+      result = (Canvas *)Canvas::getInstance();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Canvas, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_Canvas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_Canvas",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Canvas" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      delete arg1;
+      
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_preDraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_preDraw",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_preDraw" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->preDraw();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_Draw",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_Draw" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->Draw();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_postDraw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_postDraw",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_postDraw" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->postDraw();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_Render(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  StrokeRenderer *arg2 = (StrokeRenderer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_Render",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_Render" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeRenderer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_Render" "', argument " "2"" of type '" "StrokeRenderer const *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeRenderer * >(argp2);
+  {
+    try {
+      (arg1)->Render((StrokeRenderer const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_RenderBasic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  StrokeRenderer *arg2 = (StrokeRenderer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_RenderBasic",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_RenderBasic" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeRenderer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_RenderBasic" "', argument " "2"" of type '" "StrokeRenderer const *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeRenderer * >(argp2);
+  {
+    try {
+      (arg1)->RenderBasic((StrokeRenderer const *)arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_RenderStroke(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  Stroke *arg2 = (Stroke *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_RenderStroke",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_RenderStroke" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Stroke, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_RenderStroke" "', argument " "2"" of type '" "Stroke *""'"); 
+  }
+  arg2 = reinterpret_cast< Stroke * >(argp2);
+  {
+    try {
+      (arg1)->RenderStroke(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_init",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_init" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->init();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_Clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_Clear" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->Clear();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_Erase",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_Erase" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->Erase();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_readColorPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int arg5 ;
+  RGBImage *arg6 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  int val5 ;
+  int ecode5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Canvas_readColorPixels",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_readColorPixels" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_readColorPixels" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_readColorPixels" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Canvas_readColorPixels" "', argument " "4"" of type '" "int""'");
+  } 
+  arg4 = static_cast< int >(val4);
+  ecode5 = SWIG_AsVal_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Canvas_readColorPixels" "', argument " "5"" of type '" "int""'");
+  } 
+  arg5 = static_cast< int >(val5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_RGBImage,  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Canvas_readColorPixels" "', argument " "6"" of type '" "RGBImage &""'"); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Canvas_readColorPixels" "', argument " "6"" of type '" "RGBImage &""'"); 
+  }
+  arg6 = reinterpret_cast< RGBImage * >(argp6);
+  {
+    try {
+      ((Canvas const *)arg1)->readColorPixels(arg2,arg3,arg4,arg5,*arg6);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_readDepthPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int arg4 ;
+  int arg5 ;
+  GrayImage *arg6 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  int val5 ;
+  int ecode5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  PyObject * obj5 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Canvas_readDepthPixels",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_readDepthPixels" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_readDepthPixels" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_readDepthPixels" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Canvas_readDepthPixels" "', argument " "4"" of type '" "int""'");
+  } 
+  arg4 = static_cast< int >(val4);
+  ecode5 = SWIG_AsVal_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Canvas_readDepthPixels" "', argument " "5"" of type '" "int""'");
+  } 
+  arg5 = static_cast< int >(val5);
+  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_GrayImage,  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Canvas_readDepthPixels" "', argument " "6"" of type '" "GrayImage &""'"); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Canvas_readDepthPixels" "', argument " "6"" of type '" "GrayImage &""'"); 
+  }
+  arg6 = reinterpret_cast< GrayImage * >(argp6);
+  {
+    try {
+      ((Canvas const *)arg1)->readDepthPixels(arg2,arg3,arg4,arg5,*arg6);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_update",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_update" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->update();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_isEmpty",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_isEmpty" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (bool)((Canvas const *)arg1)->isEmpty();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_loadMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  unsigned int arg4 ;
+  float arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Canvas_loadMap",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_loadMap" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_loadMap" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Canvas_loadMap" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Canvas_loadMap" "', argument " "4"" of type '" "unsigned int""'");
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  ecode5 = SWIG_AsVal_float(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Canvas_loadMap" "', argument " "5"" of type '" "float""'");
+  } 
+  arg5 = static_cast< float >(val5);
+  {
+    try {
+      (arg1)->loadMap((char const *)arg2,(char const *)arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_loadMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  unsigned int arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  unsigned int val4 ;
+  int ecode4 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:Canvas_loadMap",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_loadMap" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_loadMap" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Canvas_loadMap" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Canvas_loadMap" "', argument " "4"" of type '" "unsigned int""'");
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  {
+    try {
+      (arg1)->loadMap((char const *)arg2,(char const *)arg3,arg4);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_loadMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_loadMap",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_loadMap" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_loadMap" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Canvas_loadMap" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    try {
+      (arg1)->loadMap((char const *)arg2,(char const *)arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_loadMap(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[6];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 5); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Canvas_loadMap__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_Canvas_loadMap__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_Canvas_loadMap__SWIG_0(self, args);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Canvas_loadMap'.\n  Possible C/C++ prototypes are:\n    loadMap(char const *,char const *,unsigned int,float)\n    loadMap(char const *,char const *,unsigned int)\n    loadMap(char const *,char const *)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_readMapPixel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int arg3 ;
+  int arg4 ;
+  int arg5 ;
+  float result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  int val5 ;
+  int ecode5 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  PyObject * obj4 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Canvas_readMapPixel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_readMapPixel" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_readMapPixel" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_readMapPixel" "', argument " "3"" of type '" "int""'");
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(obj3, &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Canvas_readMapPixel" "', argument " "4"" of type '" "int""'");
+  } 
+  arg4 = static_cast< int >(val4);
+  ecode5 = SWIG_AsVal_int(obj4, &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Canvas_readMapPixel" "', argument " "5"" of type '" "int""'");
+  } 
+  arg5 = static_cast< int >(val5);
+  {
+    try {
+      result = (float)(arg1)->readMapPixel((char const *)arg2,arg3,arg4,arg5);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_float(static_cast< float >(result));
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_loadSteerableViewMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  SteerableViewMap *arg2 = (SteerableViewMap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_loadSteerableViewMap",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_loadSteerableViewMap" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_SteerableViewMap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_loadSteerableViewMap" "', argument " "2"" of type '" "SteerableViewMap *""'"); 
+  }
+  arg2 = reinterpret_cast< SteerableViewMap * >(argp2);
+  {
+    try {
+      (arg1)->loadSteerableViewMap(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_getSteerableViewMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  SteerableViewMap *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_getSteerableViewMap",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_getSteerableViewMap" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (SteerableViewMap *)(arg1)->getSteerableViewMap();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SteerableViewMap, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_selectedFEdge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_selectedFEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_selectedFEdge" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (FEdge *)((Canvas const *)arg1)->selectedFEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_selectedFEdge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_selectedFEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_selectedFEdge" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->selectedFEdge();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_selectedFEdge(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Canvas_selectedFEdge__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Canvas_selectedFEdge__SWIG_0(self, args);
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Canvas_selectedFEdge'.\n  Possible C/C++ prototypes are:\n    selectedFEdge()\n    selectedFEdge()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_width(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_width",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_width" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (int)((Canvas const *)arg1)->width();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_height",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_height" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (int)((Canvas const *)arg1)->height();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_currentPaperTextureIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_currentPaperTextureIndex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_currentPaperTextureIndex" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (int)((Canvas const *)arg1)->currentPaperTextureIndex();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_scene3DBBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  SwigValueWrapper<BBox<VecMat::Vec3<double > > > result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_scene3DBBox",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_scene3DBBox" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = ((Canvas const *)arg1)->scene3DBBox();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj((new BBox<Geometry::Vec3r >(static_cast< const BBox<Geometry::Vec3r >& >(result))), SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_renderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  StrokeRenderer *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_renderer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_renderer" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (StrokeRenderer *)((Canvas const *)arg1)->renderer();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeRenderer, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_getCurrentStyleModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  StyleModule *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_getCurrentStyleModule",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_getCurrentStyleModule" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (StyleModule *)(arg1)->getCurrentStyleModule();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StyleModule, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_getRecordFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  bool result;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_getRecordFlag",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_getRecordFlag" "', argument " "1"" of type '" "Canvas const *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      result = (bool)((Canvas const *)arg1)->getRecordFlag();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_From_bool(static_cast< bool >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_setSelectedFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  FEdge *arg2 = (FEdge *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_setSelectedFEdge",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_setSelectedFEdge" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEdge, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_setSelectedFEdge" "', argument " "2"" of type '" "FEdge *""'"); 
+  }
+  arg2 = reinterpret_cast< FEdge * >(argp2);
+  {
+    try {
+      (arg1)->setSelectedFEdge(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_InsertStyleModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  StyleModule *arg3 = (StyleModule *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_InsertStyleModule",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_InsertStyleModule" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_InsertStyleModule" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_StyleModule, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Canvas_InsertStyleModule" "', argument " "3"" of type '" "StyleModule *""'"); 
+  }
+  arg3 = reinterpret_cast< StyleModule * >(argp3);
+  {
+    try {
+      (arg1)->InsertStyleModule(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_RemoveStyleModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_RemoveStyleModule",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_RemoveStyleModule" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_RemoveStyleModule" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  {
+    try {
+      (arg1)->RemoveStyleModule(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_SwapStyleModules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  unsigned int arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_SwapStyleModules",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_SwapStyleModules" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_SwapStyleModules" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_SwapStyleModules" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  {
+    try {
+      (arg1)->SwapStyleModules(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_ReplaceStyleModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  StyleModule *arg3 = (StyleModule *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_ReplaceStyleModule",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_ReplaceStyleModule" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_ReplaceStyleModule" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_StyleModule, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Canvas_ReplaceStyleModule" "', argument " "3"" of type '" "StyleModule *""'"); 
+  }
+  arg3 = reinterpret_cast< StyleModule * >(argp3);
+  {
+    try {
+      (arg1)->ReplaceStyleModule(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_setVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_setVisible",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_setVisible" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_setVisible" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_setVisible" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setVisible(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_AddLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  StrokeLayer *arg2 = (StrokeLayer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_AddLayer",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_AddLayer" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StrokeLayer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_AddLayer" "', argument " "2"" of type '" "StrokeLayer *""'"); 
+  }
+  arg2 = reinterpret_cast< StrokeLayer * >(argp2);
+  {
+    try {
+      (arg1)->AddLayer(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_setCurrentPaperTextureIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_setCurrentPaperTextureIndex",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_setCurrentPaperTextureIndex" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_setCurrentPaperTextureIndex" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      (arg1)->setCurrentPaperTextureIndex(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_changePaperTexture__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_changePaperTexture",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_changePaperTexture" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_changePaperTexture" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->changePaperTexture(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_changePaperTexture__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_changePaperTexture",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_changePaperTexture" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->changePaperTexture();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_changePaperTexture(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Canvas_changePaperTexture__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Canvas_changePaperTexture__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Canvas_changePaperTexture'.\n  Possible C/C++ prototypes are:\n    changePaperTexture(bool)\n    changePaperTexture()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_togglePaperTexture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_togglePaperTexture",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_togglePaperTexture" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->togglePaperTexture();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_resetModified__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_resetModified",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_resetModified" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_bool(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_resetModified" "', argument " "2"" of type '" "bool""'");
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->resetModified(arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_resetModified__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:Canvas_resetModified",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_resetModified" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  {
+    try {
+      (arg1)->resetModified();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_resetModified(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[3];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 2); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Canvas_resetModified__SWIG_1(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_Canvas_resetModified__SWIG_0(self, args);
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Canvas_resetModified'.\n  Possible C/C++ prototypes are:\n    resetModified(bool)\n    resetModified()\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_causalStyleModules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  std::vector<unsigned int,std::allocator<unsigned int > > *arg2 = 0 ;
+  unsigned int arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_causalStyleModules",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_causalStyleModules" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_causalStyleModules" "', argument " "2"" of type '" "std::vector<unsigned int,std::allocator<unsigned int > > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Canvas_causalStyleModules" "', argument " "2"" of type '" "std::vector<unsigned int,std::allocator<unsigned int > > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<unsigned int,std::allocator<unsigned int > > * >(argp2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_causalStyleModules" "', argument " "3"" of type '" "unsigned int""'");
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  {
+    try {
+      (arg1)->causalStyleModules(*arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_causalStyleModules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  std::vector<unsigned int,std::allocator<unsigned int > > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:Canvas_causalStyleModules",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_causalStyleModules" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Canvas_causalStyleModules" "', argument " "2"" of type '" "std::vector<unsigned int,std::allocator<unsigned int > > &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Canvas_causalStyleModules" "', argument " "2"" of type '" "std::vector<unsigned int,std::allocator<unsigned int > > &""'"); 
+  }
+  arg2 = reinterpret_cast< std::vector<unsigned int,std::allocator<unsigned int > > * >(argp2);
+  {
+    try {
+      (arg1)->causalStyleModules(*arg2);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_causalStyleModules(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[4];
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = PyObject_Length(args);
+  for (ii = 0; (ii < argc) && (ii < 3); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Canvas_causalStyleModules__SWIG_1(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Canvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_Canvas_causalStyleModules__SWIG_0(self, args);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Canvas_causalStyleModules'.\n  Possible C/C++ prototypes are:\n    causalStyleModules(std::vector<unsigned int,std::allocator<unsigned int > > &,unsigned int)\n    causalStyleModules(std::vector<unsigned int,std::allocator<unsigned int > > &)\n");
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Canvas_setModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Canvas *arg1 = (Canvas *) 0 ;
+  unsigned int arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:Canvas_setModified",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Canvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Canvas_setModified" "', argument " "1"" of type '" "Canvas *""'"); 
+  }
+  arg1 = reinterpret_cast< Canvas * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Canvas_setModified" "', argument " "2"" of type '" "unsigned int""'");
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  ecode3 = SWIG_AsVal_bool(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Canvas_setModified" "', argument " "3"" of type '" "bool""'");
+  } 
+  arg3 = static_cast< bool >(val3);
+  {
+    try {
+      (arg1)->setModified(arg2,arg3);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *Canvas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_Canvas, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_castToSVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  SVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToSVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToSVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (SVertex *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,SVertex >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToViewVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  ViewVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToViewVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToViewVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (ViewVertex *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,ViewVertex >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  TVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToTVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (TVertex *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,TVertex >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToCurvePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  CurvePoint *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToCurvePoint",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToCurvePoint" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (CurvePoint *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,CurvePoint >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CurvePoint, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToStrokeVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  StrokeVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToStrokeVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToStrokeVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (StrokeVertex *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,StrokeVertex >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_StrokeVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToNonTVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface0D *arg1 = (Interface0D *) 0 ;
+  NonTVertex *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToNonTVertex",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface0D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToNonTVertex" "', argument " "1"" of type '" "Interface0D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface0D * >(argp1);
+  {
+    try {
+      result = (NonTVertex *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface0D,NonTVertex >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NonTVertex, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToFEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  FEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToFEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToFEdge" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (FEdge *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface1D,FEdge >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToViewEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  ViewEdge *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToViewEdge",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToViewEdge" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (ViewEdge *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface1D,ViewEdge >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ViewEdge, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToStroke(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Stroke *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToStroke",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToStroke" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (Stroke *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface1D,Stroke >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Stroke, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_castToChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  Interface1D *arg1 = (Interface1D *) 0 ;
+  Chain *result = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:castToChain",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Interface1D, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "castToChain" "', argument " "1"" of type '" "Interface1D *""'"); 
+  }
+  arg1 = reinterpret_cast< Interface1D * >(argp1);
+  {
+    try {
+      result = (Chain *)Cast::SWIGTEMPLATEDISAMBIGUATOR cast<Interface1D,Chain >(arg1);
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      cout << "Warning: return type mismatch" << endl;
+    //    }
+    catch (Swig::DirectorException&) {
+      cout << "Warning: director exception catched" << endl;
+    }
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Chain, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+static PyMethodDef SwigMethods[] = {
+	 { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_incr", _wrap_PySwigIterator_incr, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_decr", _wrap_PySwigIterator_decr, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_distance", _wrap_PySwigIterator_distance, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_equal", _wrap_PySwigIterator_equal, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_advance", _wrap_PySwigIterator_advance, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___eq__", _wrap_PySwigIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___ne__", _wrap_PySwigIterator___ne__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___iadd__", _wrap_PySwigIterator___iadd__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___isub__", _wrap_PySwigIterator___isub__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___add__", _wrap_PySwigIterator___add__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, NULL},
+	 { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_iterator", _wrap_vectorInt_iterator, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___nonzero__", _wrap_vectorInt___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___len__", _wrap_vectorInt___len__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_pop", _wrap_vectorInt_pop, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___getslice__", _wrap_vectorInt___getslice__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___setslice__", _wrap_vectorInt___setslice__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___delslice__", _wrap_vectorInt___delslice__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___delitem__", _wrap_vectorInt___delitem__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___getitem__", _wrap_vectorInt___getitem__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt___setitem__", _wrap_vectorInt___setitem__, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_append", _wrap_vectorInt_append, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_empty", _wrap_vectorInt_empty, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_size", _wrap_vectorInt_size, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_clear", _wrap_vectorInt_clear, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_swap", _wrap_vectorInt_swap, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_get_allocator", _wrap_vectorInt_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_begin", _wrap_vectorInt_begin, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_end", _wrap_vectorInt_end, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_rbegin", _wrap_vectorInt_rbegin, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_rend", _wrap_vectorInt_rend, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_pop_back", _wrap_vectorInt_pop_back, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_erase", _wrap_vectorInt_erase, METH_VARARGS, NULL},
+	 { (char *)"new_vectorInt", _wrap_new_vectorInt, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_push_back", _wrap_vectorInt_push_back, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_front", _wrap_vectorInt_front, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_back", _wrap_vectorInt_back, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_assign", _wrap_vectorInt_assign, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_resize", _wrap_vectorInt_resize, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_insert", _wrap_vectorInt_insert, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_reserve", _wrap_vectorInt_reserve, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_capacity", _wrap_vectorInt_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_vectorInt", _wrap_delete_vectorInt, METH_VARARGS, NULL},
+	 { (char *)"vectorInt_swigregister", vectorInt_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Id", _wrap_new_Id, METH_VARARGS, NULL},
+	 { (char *)"Id_getFirst", _wrap_Id_getFirst, METH_VARARGS, NULL},
+	 { (char *)"Id_getSecond", _wrap_Id_getSecond, METH_VARARGS, NULL},
+	 { (char *)"Id_setFirst", _wrap_Id_setFirst, METH_VARARGS, NULL},
+	 { (char *)"Id_setSecond", _wrap_Id_setSecond, METH_VARARGS, NULL},
+	 { (char *)"Id___eq__", _wrap_Id___eq__, METH_VARARGS, NULL},
+	 { (char *)"Id___ne__", _wrap_Id___ne__, METH_VARARGS, NULL},
+	 { (char *)"Id___lt__", _wrap_Id___lt__, METH_VARARGS, NULL},
+	 { (char *)"delete_Id", _wrap_delete_Id, METH_VARARGS, NULL},
+	 { (char *)"Id_swigregister", Id_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_2u", _wrap_new_Vec_2u, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_2u", _wrap_delete_Vec_2u, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_dim", _wrap_Vec_2u_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_norm", _wrap_Vec_2u_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_squareNorm", _wrap_Vec_2u_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_normalize", _wrap_Vec_2u_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_normalizeSafe", _wrap_Vec_2u_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___add__", _wrap_Vec_2u___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___sub__", _wrap_Vec_2u___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___div__", _wrap_Vec_2u___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___mul__", _wrap_Vec_2u___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___eq__", _wrap_Vec_2u___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___ne__", _wrap_Vec_2u___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___lt__", _wrap_Vec_2u___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u___gt__", _wrap_Vec_2u___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2u_swigregister", Vec_2u_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_2i", _wrap_new_Vec_2i, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_2i", _wrap_delete_Vec_2i, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_dim", _wrap_Vec_2i_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_norm", _wrap_Vec_2i_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_squareNorm", _wrap_Vec_2i_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_normalize", _wrap_Vec_2i_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_normalizeSafe", _wrap_Vec_2i_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___add__", _wrap_Vec_2i___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___sub__", _wrap_Vec_2i___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___div__", _wrap_Vec_2i___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___mul__", _wrap_Vec_2i___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___eq__", _wrap_Vec_2i___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___ne__", _wrap_Vec_2i___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___lt__", _wrap_Vec_2i___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i___gt__", _wrap_Vec_2i___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2i_swigregister", Vec_2i_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_2d", _wrap_new_Vec_2d, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_2d", _wrap_delete_Vec_2d, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_dim", _wrap_Vec_2d_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_norm", _wrap_Vec_2d_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_squareNorm", _wrap_Vec_2d_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_normalize", _wrap_Vec_2d_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_normalizeSafe", _wrap_Vec_2d_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___add__", _wrap_Vec_2d___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___sub__", _wrap_Vec_2d___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___div__", _wrap_Vec_2d___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___mul__", _wrap_Vec_2d___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___eq__", _wrap_Vec_2d___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___ne__", _wrap_Vec_2d___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___lt__", _wrap_Vec_2d___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d___gt__", _wrap_Vec_2d___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2d_swigregister", Vec_2d_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_2f", _wrap_new_Vec_2f, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_2f", _wrap_delete_Vec_2f, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_dim", _wrap_Vec_2f_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_norm", _wrap_Vec_2f_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_squareNorm", _wrap_Vec_2f_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_normalize", _wrap_Vec_2f_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_normalizeSafe", _wrap_Vec_2f_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___add__", _wrap_Vec_2f___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___sub__", _wrap_Vec_2f___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___div__", _wrap_Vec_2f___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___mul__", _wrap_Vec_2f___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___eq__", _wrap_Vec_2f___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___ne__", _wrap_Vec_2f___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___lt__", _wrap_Vec_2f___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f___gt__", _wrap_Vec_2f___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_2f_swigregister", Vec_2f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec2u", _wrap_new_Vec2u, METH_VARARGS, NULL},
+	 { (char *)"Vec2u_x", _wrap_Vec2u_x, METH_VARARGS, NULL},
+	 { (char *)"Vec2u_y", _wrap_Vec2u_y, METH_VARARGS, NULL},
+	 { (char *)"Vec2u_setX", _wrap_Vec2u_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec2u_setY", _wrap_Vec2u_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec2u___add__", _wrap_Vec2u___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec2u___sub__", _wrap_Vec2u___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec2u___div__", _wrap_Vec2u___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec2u___mul__", _wrap_Vec2u___mul__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec2u", _wrap_delete_Vec2u, METH_VARARGS, NULL},
+	 { (char *)"Vec2u_swigregister", Vec2u_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec2i", _wrap_new_Vec2i, METH_VARARGS, NULL},
+	 { (char *)"Vec2i_x", _wrap_Vec2i_x, METH_VARARGS, NULL},
+	 { (char *)"Vec2i_y", _wrap_Vec2i_y, METH_VARARGS, NULL},
+	 { (char *)"Vec2i_setX", _wrap_Vec2i_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec2i_setY", _wrap_Vec2i_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec2i___add__", _wrap_Vec2i___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec2i___sub__", _wrap_Vec2i___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec2i___div__", _wrap_Vec2i___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec2i___mul__", _wrap_Vec2i___mul__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec2i", _wrap_delete_Vec2i, METH_VARARGS, NULL},
+	 { (char *)"Vec2i_swigregister", Vec2i_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec2f", _wrap_new_Vec2f, METH_VARARGS, NULL},
+	 { (char *)"Vec2f_x", _wrap_Vec2f_x, METH_VARARGS, NULL},
+	 { (char *)"Vec2f_y", _wrap_Vec2f_y, METH_VARARGS, NULL},
+	 { (char *)"Vec2f_setX", _wrap_Vec2f_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec2f_setY", _wrap_Vec2f_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec2f___add__", _wrap_Vec2f___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec2f___sub__", _wrap_Vec2f___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec2f___div__", _wrap_Vec2f___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec2f___mul__", _wrap_Vec2f___mul__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec2f", _wrap_delete_Vec2f, METH_VARARGS, NULL},
+	 { (char *)"Vec2f_swigregister", Vec2f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec2d", _wrap_new_Vec2d, METH_VARARGS, NULL},
+	 { (char *)"Vec2d_x", _wrap_Vec2d_x, METH_VARARGS, NULL},
+	 { (char *)"Vec2d_y", _wrap_Vec2d_y, METH_VARARGS, NULL},
+	 { (char *)"Vec2d_setX", _wrap_Vec2d_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec2d_setY", _wrap_Vec2d_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec2d___add__", _wrap_Vec2d___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec2d___sub__", _wrap_Vec2d___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec2d___div__", _wrap_Vec2d___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec2d___mul__", _wrap_Vec2d___mul__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec2d", _wrap_delete_Vec2d, METH_VARARGS, NULL},
+	 { (char *)"Vec2d_swigregister", Vec2d_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_3u", _wrap_new_Vec_3u, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_3u", _wrap_delete_Vec_3u, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_dim", _wrap_Vec_3u_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_norm", _wrap_Vec_3u_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_squareNorm", _wrap_Vec_3u_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_normalize", _wrap_Vec_3u_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_normalizeSafe", _wrap_Vec_3u_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___add__", _wrap_Vec_3u___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___sub__", _wrap_Vec_3u___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___div__", _wrap_Vec_3u___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___mul__", _wrap_Vec_3u___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___eq__", _wrap_Vec_3u___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___ne__", _wrap_Vec_3u___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___lt__", _wrap_Vec_3u___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u___gt__", _wrap_Vec_3u___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3u_swigregister", Vec_3u_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_3i", _wrap_new_Vec_3i, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_3i", _wrap_delete_Vec_3i, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_dim", _wrap_Vec_3i_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_norm", _wrap_Vec_3i_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_squareNorm", _wrap_Vec_3i_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_normalize", _wrap_Vec_3i_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_normalizeSafe", _wrap_Vec_3i_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___add__", _wrap_Vec_3i___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___sub__", _wrap_Vec_3i___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___div__", _wrap_Vec_3i___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___mul__", _wrap_Vec_3i___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___eq__", _wrap_Vec_3i___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___ne__", _wrap_Vec_3i___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___lt__", _wrap_Vec_3i___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i___gt__", _wrap_Vec_3i___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3i_swigregister", Vec_3i_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_3d", _wrap_new_Vec_3d, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_3d", _wrap_delete_Vec_3d, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_dim", _wrap_Vec_3d_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_norm", _wrap_Vec_3d_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_squareNorm", _wrap_Vec_3d_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_normalize", _wrap_Vec_3d_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_normalizeSafe", _wrap_Vec_3d_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___add__", _wrap_Vec_3d___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___sub__", _wrap_Vec_3d___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___div__", _wrap_Vec_3d___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___mul__", _wrap_Vec_3d___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___eq__", _wrap_Vec_3d___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___ne__", _wrap_Vec_3d___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___lt__", _wrap_Vec_3d___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d___gt__", _wrap_Vec_3d___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3d_swigregister", Vec_3d_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec_3f", _wrap_new_Vec_3f, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec_3f", _wrap_delete_Vec_3f, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_dim", _wrap_Vec_3f_dim, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_norm", _wrap_Vec_3f_norm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_squareNorm", _wrap_Vec_3f_squareNorm, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_normalize", _wrap_Vec_3f_normalize, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_normalizeSafe", _wrap_Vec_3f_normalizeSafe, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___add__", _wrap_Vec_3f___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___sub__", _wrap_Vec_3f___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___div__", _wrap_Vec_3f___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___mul__", _wrap_Vec_3f___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___eq__", _wrap_Vec_3f___eq__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___ne__", _wrap_Vec_3f___ne__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___lt__", _wrap_Vec_3f___lt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f___gt__", _wrap_Vec_3f___gt__, METH_VARARGS, NULL},
+	 { (char *)"Vec_3f_swigregister", Vec_3f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec3u", _wrap_new_Vec3u, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_x", _wrap_Vec3u_x, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_y", _wrap_Vec3u_y, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_z", _wrap_Vec3u_z, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_setX", _wrap_Vec3u_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_setY", _wrap_Vec3u_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_setZ", _wrap_Vec3u_setZ, METH_VARARGS, NULL},
+	 { (char *)"Vec3u___add__", _wrap_Vec3u___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec3u___sub__", _wrap_Vec3u___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec3u___div__", _wrap_Vec3u___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec3u___mul__", _wrap_Vec3u___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec3u___xor__", _wrap_Vec3u___xor__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec3u", _wrap_delete_Vec3u, METH_VARARGS, NULL},
+	 { (char *)"Vec3u_swigregister", Vec3u_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec3i", _wrap_new_Vec3i, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_x", _wrap_Vec3i_x, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_y", _wrap_Vec3i_y, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_z", _wrap_Vec3i_z, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_setX", _wrap_Vec3i_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_setY", _wrap_Vec3i_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_setZ", _wrap_Vec3i_setZ, METH_VARARGS, NULL},
+	 { (char *)"Vec3i___add__", _wrap_Vec3i___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec3i___sub__", _wrap_Vec3i___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec3i___div__", _wrap_Vec3i___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec3i___mul__", _wrap_Vec3i___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec3i___xor__", _wrap_Vec3i___xor__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec3i", _wrap_delete_Vec3i, METH_VARARGS, NULL},
+	 { (char *)"Vec3i_swigregister", Vec3i_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec3f", _wrap_new_Vec3f, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_x", _wrap_Vec3f_x, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_y", _wrap_Vec3f_y, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_z", _wrap_Vec3f_z, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_setX", _wrap_Vec3f_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_setY", _wrap_Vec3f_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_setZ", _wrap_Vec3f_setZ, METH_VARARGS, NULL},
+	 { (char *)"Vec3f___add__", _wrap_Vec3f___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec3f___sub__", _wrap_Vec3f___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec3f___div__", _wrap_Vec3f___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec3f___mul__", _wrap_Vec3f___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec3f___xor__", _wrap_Vec3f___xor__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec3f", _wrap_delete_Vec3f, METH_VARARGS, NULL},
+	 { (char *)"Vec3f_swigregister", Vec3f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Vec3d", _wrap_new_Vec3d, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_x", _wrap_Vec3d_x, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_y", _wrap_Vec3d_y, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_z", _wrap_Vec3d_z, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_setX", _wrap_Vec3d_setX, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_setY", _wrap_Vec3d_setY, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_setZ", _wrap_Vec3d_setZ, METH_VARARGS, NULL},
+	 { (char *)"Vec3d___add__", _wrap_Vec3d___add__, METH_VARARGS, NULL},
+	 { (char *)"Vec3d___sub__", _wrap_Vec3d___sub__, METH_VARARGS, NULL},
+	 { (char *)"Vec3d___div__", _wrap_Vec3d___div__, METH_VARARGS, NULL},
+	 { (char *)"Vec3d___mul__", _wrap_Vec3d___mul__, METH_VARARGS, NULL},
+	 { (char *)"Vec3d___xor__", _wrap_Vec3d___xor__, METH_VARARGS, NULL},
+	 { (char *)"delete_Vec3d", _wrap_delete_Vec3d, METH_VARARGS, NULL},
+	 { (char *)"Vec3d_swigregister", Vec3d_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Noise", _wrap_new_Noise, METH_VARARGS, NULL},
+	 { (char *)"delete_Noise", _wrap_delete_Noise, METH_VARARGS, NULL},
+	 { (char *)"Noise_turbulence1", _wrap_Noise_turbulence1, METH_VARARGS, NULL},
+	 { (char *)"Noise_turbulence2", _wrap_Noise_turbulence2, METH_VARARGS, NULL},
+	 { (char *)"Noise_turbulence3", _wrap_Noise_turbulence3, METH_VARARGS, NULL},
+	 { (char *)"Noise_smoothNoise1", _wrap_Noise_smoothNoise1, METH_VARARGS, NULL},
+	 { (char *)"Noise_smoothNoise2", _wrap_Noise_smoothNoise2, METH_VARARGS, NULL},
+	 { (char *)"Noise_smoothNoise3", _wrap_Noise_smoothNoise3, METH_VARARGS, NULL},
+	 { (char *)"Noise_swigregister", Noise_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Material", _wrap_new_Material, METH_VARARGS, NULL},
+	 { (char *)"delete_Material", _wrap_delete_Material, METH_VARARGS, NULL},
+	 { (char *)"Material_diffuse", _wrap_Material_diffuse, METH_VARARGS, NULL},
+	 { (char *)"Material_diffuseR", _wrap_Material_diffuseR, METH_VARARGS, NULL},
+	 { (char *)"Material_diffuseG", _wrap_Material_diffuseG, METH_VARARGS, NULL},
+	 { (char *)"Material_diffuseB", _wrap_Material_diffuseB, METH_VARARGS, NULL},
+	 { (char *)"Material_diffuseA", _wrap_Material_diffuseA, METH_VARARGS, NULL},
+	 { (char *)"Material_specular", _wrap_Material_specular, METH_VARARGS, NULL},
+	 { (char *)"Material_specularR", _wrap_Material_specularR, METH_VARARGS, NULL},
+	 { (char *)"Material_specularG", _wrap_Material_specularG, METH_VARARGS, NULL},
+	 { (char *)"Material_specularB", _wrap_Material_specularB, METH_VARARGS, NULL},
+	 { (char *)"Material_specularA", _wrap_Material_specularA, METH_VARARGS, NULL},
+	 { (char *)"Material_ambient", _wrap_Material_ambient, METH_VARARGS, NULL},
+	 { (char *)"Material_ambientR", _wrap_Material_ambientR, METH_VARARGS, NULL},
+	 { (char *)"Material_ambientG", _wrap_Material_ambientG, METH_VARARGS, NULL},
+	 { (char *)"Material_ambientB", _wrap_Material_ambientB, METH_VARARGS, NULL},
+	 { (char *)"Material_ambientA", _wrap_Material_ambientA, METH_VARARGS, NULL},
+	 { (char *)"Material_emission", _wrap_Material_emission, METH_VARARGS, NULL},
+	 { (char *)"Material_emissionR", _wrap_Material_emissionR, METH_VARARGS, NULL},
+	 { (char *)"Material_emissionG", _wrap_Material_emissionG, METH_VARARGS, NULL},
+	 { (char *)"Material_emissionB", _wrap_Material_emissionB, METH_VARARGS, NULL},
+	 { (char *)"Material_emissionA", _wrap_Material_emissionA, METH_VARARGS, NULL},
+	 { (char *)"Material_shininess", _wrap_Material_shininess, METH_VARARGS, NULL},
+	 { (char *)"Material_setDiffuse", _wrap_Material_setDiffuse, METH_VARARGS, NULL},
+	 { (char *)"Material_setSpecular", _wrap_Material_setSpecular, METH_VARARGS, NULL},
+	 { (char *)"Material_setAmbient", _wrap_Material_setAmbient, METH_VARARGS, NULL},
+	 { (char *)"Material_setEmission", _wrap_Material_setEmission, METH_VARARGS, NULL},
+	 { (char *)"Material_setShininess", _wrap_Material_setShininess, METH_VARARGS, NULL},
+	 { (char *)"Material___ne__", _wrap_Material___ne__, METH_VARARGS, NULL},
+	 { (char *)"Material___eq__", _wrap_Material___eq__, METH_VARARGS, NULL},
+	 { (char *)"Material_swigregister", Material_swigregister, METH_VARARGS, NULL},
+	 { (char *)"delete_Interface0D", _wrap_delete_Interface0D, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getExactTypeName", _wrap_Interface0D_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getX", _wrap_Interface0D_getX, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getY", _wrap_Interface0D_getY, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getZ", _wrap_Interface0D_getZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getPoint3D", _wrap_Interface0D_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getProjectedX", _wrap_Interface0D_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getProjectedY", _wrap_Interface0D_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getProjectedZ", _wrap_Interface0D_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getPoint2D", _wrap_Interface0D_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getFEdge", _wrap_Interface0D_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getId", _wrap_Interface0D_getId, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_getNature", _wrap_Interface0D_getNature, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_castToSVertex", _wrap_Interface0D_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_castToViewVertex", _wrap_Interface0D_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_castToNonTVertex", _wrap_Interface0D_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_castToTVertex", _wrap_Interface0D_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"new_Interface0D", _wrap_new_Interface0D, METH_VARARGS, NULL},
+	 { (char *)"Interface0D_swigregister", Interface0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"delete_Interface0DIteratorNested", _wrap_delete_Interface0DIteratorNested, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getExactTypeName", _wrap_Interface0DIteratorNested_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getObject", _wrap_Interface0DIteratorNested_getObject, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested___deref__", _wrap_Interface0DIteratorNested___deref__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_increment", _wrap_Interface0DIteratorNested_increment, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_decrement", _wrap_Interface0DIteratorNested_decrement, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_isBegin", _wrap_Interface0DIteratorNested_isBegin, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_isEnd", _wrap_Interface0DIteratorNested_isEnd, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested___eq__", _wrap_Interface0DIteratorNested___eq__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested___ne__", _wrap_Interface0DIteratorNested___ne__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_t", _wrap_Interface0DIteratorNested_t, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_u", _wrap_Interface0DIteratorNested_u, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_copy", _wrap_Interface0DIteratorNested_copy, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getX", _wrap_Interface0DIteratorNested_getX, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getY", _wrap_Interface0DIteratorNested_getY, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getZ", _wrap_Interface0DIteratorNested_getZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getPoint3D", _wrap_Interface0DIteratorNested_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getProjectedX", _wrap_Interface0DIteratorNested_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getProjectedY", _wrap_Interface0DIteratorNested_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getProjectedZ", _wrap_Interface0DIteratorNested_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getPoint2D", _wrap_Interface0DIteratorNested_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getFEdge", _wrap_Interface0DIteratorNested_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getId", _wrap_Interface0DIteratorNested_getId, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_getNature", _wrap_Interface0DIteratorNested_getNature, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_castToSVertex", _wrap_Interface0DIteratorNested_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_castToViewVertex", _wrap_Interface0DIteratorNested_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_castToNonTVertex", _wrap_Interface0DIteratorNested_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_castToTVertex", _wrap_Interface0DIteratorNested_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIteratorNested_swigregister", Interface0DIteratorNested_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Interface0DIterator", _wrap_new_Interface0DIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_Interface0DIterator", _wrap_delete_Interface0DIterator, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getExactTypeName", _wrap_Interface0DIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getObject", _wrap_Interface0DIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator___deref__", _wrap_Interface0DIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_increment", _wrap_Interface0DIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_decrement", _wrap_Interface0DIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_isBegin", _wrap_Interface0DIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_isEnd", _wrap_Interface0DIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator___eq__", _wrap_Interface0DIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator___ne__", _wrap_Interface0DIterator___ne__, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_t", _wrap_Interface0DIterator_t, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_u", _wrap_Interface0DIterator_u, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getX", _wrap_Interface0DIterator_getX, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getY", _wrap_Interface0DIterator_getY, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getZ", _wrap_Interface0DIterator_getZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getPoint3D", _wrap_Interface0DIterator_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getProjectedX", _wrap_Interface0DIterator_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getProjectedY", _wrap_Interface0DIterator_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getProjectedZ", _wrap_Interface0DIterator_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getPoint2D", _wrap_Interface0DIterator_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getFEdge", _wrap_Interface0DIterator_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getId", _wrap_Interface0DIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_getNature", _wrap_Interface0DIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_castToSVertex", _wrap_Interface0DIterator_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_castToViewVertex", _wrap_Interface0DIterator_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_castToNonTVertex", _wrap_Interface0DIterator_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_castToTVertex", _wrap_Interface0DIterator_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"Interface0DIterator_swigregister", Interface0DIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Interface1D", _wrap_new_Interface1D, METH_VARARGS, NULL},
+	 { (char *)"delete_Interface1D", _wrap_delete_Interface1D, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_getExactTypeName", _wrap_Interface1D_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_verticesBegin", _wrap_Interface1D_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_verticesEnd", _wrap_Interface1D_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_pointsBegin", _wrap_Interface1D_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_pointsEnd", _wrap_Interface1D_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_getLength2D", _wrap_Interface1D_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_getId", _wrap_Interface1D_getId, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_getNature", _wrap_Interface1D_getNature, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_getTimeStamp", _wrap_Interface1D_getTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_setTimeStamp", _wrap_Interface1D_setTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"Interface1D_swigregister", Interface1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"integrateUnsigned", _wrap_integrateUnsigned, METH_VARARGS, NULL},
+	 { (char *)"integrateFloat", _wrap_integrateFloat, METH_VARARGS, NULL},
+	 { (char *)"integrateDouble", _wrap_integrateDouble, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getExactTypeName", _wrap_SVertex_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getX", _wrap_SVertex_getX, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getY", _wrap_SVertex_getY, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getZ", _wrap_SVertex_getZ, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getPoint3D", _wrap_SVertex_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getProjectedX", _wrap_SVertex_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getProjectedY", _wrap_SVertex_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getProjectedZ", _wrap_SVertex_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getPoint2D", _wrap_SVertex_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getFEdge", _wrap_SVertex_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getId", _wrap_SVertex_getId, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getNature", _wrap_SVertex_getNature, METH_VARARGS, NULL},
+	 { (char *)"SVertex_castToSVertex", _wrap_SVertex_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_castToViewVertex", _wrap_SVertex_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_castToNonTVertex", _wrap_SVertex_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_castToTVertex", _wrap_SVertex_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_userdata_set", _wrap_SVertex_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"SVertex_userdata_get", _wrap_SVertex_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_SVertex", _wrap_new_SVertex, METH_VARARGS, NULL},
+	 { (char *)"delete_SVertex", _wrap_delete_SVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_duplicate", _wrap_SVertex_duplicate, METH_VARARGS, NULL},
+	 { (char *)"SVertex___eq__", _wrap_SVertex___eq__, METH_VARARGS, NULL},
+	 { (char *)"SVertex_point3D", _wrap_SVertex_point3D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_point2D", _wrap_SVertex_point2D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_normals", _wrap_SVertex_normals, METH_VARARGS, NULL},
+	 { (char *)"SVertex_normalsSize", _wrap_SVertex_normalsSize, METH_VARARGS, NULL},
+	 { (char *)"SVertex_fedges", _wrap_SVertex_fedges, METH_VARARGS, NULL},
+	 { (char *)"SVertex_fedges_begin", _wrap_SVertex_fedges_begin, METH_VARARGS, NULL},
+	 { (char *)"SVertex_fedges_end", _wrap_SVertex_fedges_end, METH_VARARGS, NULL},
+	 { (char *)"SVertex_z", _wrap_SVertex_z, METH_VARARGS, NULL},
+	 { (char *)"SVertex_viewvertex", _wrap_SVertex_viewvertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setPoint3D", _wrap_SVertex_setPoint3D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setPoint2D", _wrap_SVertex_setPoint2D, METH_VARARGS, NULL},
+	 { (char *)"SVertex_AddNormal", _wrap_SVertex_AddNormal, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setCurvatureInfo", _wrap_SVertex_setCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_getCurvatureInfo", _wrap_SVertex_getCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setCurvatureFredo", _wrap_SVertex_setCurvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setDirectionFredo", _wrap_SVertex_setDirectionFredo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_curvatureFredo", _wrap_SVertex_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_directionFredo", _wrap_SVertex_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setId", _wrap_SVertex_setId, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setFEdges", _wrap_SVertex_setFEdges, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setShape", _wrap_SVertex_setShape, METH_VARARGS, NULL},
+	 { (char *)"SVertex_setViewVertex", _wrap_SVertex_setViewVertex, METH_VARARGS, NULL},
+	 { (char *)"SVertex_AddFEdge", _wrap_SVertex_AddFEdge, METH_VARARGS, NULL},
+	 { (char *)"SVertex_Replace", _wrap_SVertex_Replace, METH_VARARGS, NULL},
+	 { (char *)"SVertex_fedge", _wrap_SVertex_fedge, METH_VARARGS, NULL},
+	 { (char *)"SVertex_point2d", _wrap_SVertex_point2d, METH_VARARGS, NULL},
+	 { (char *)"SVertex_point3d", _wrap_SVertex_point3d, METH_VARARGS, NULL},
+	 { (char *)"SVertex_normal", _wrap_SVertex_normal, METH_VARARGS, NULL},
+	 { (char *)"SVertex_shape_id", _wrap_SVertex_shape_id, METH_VARARGS, NULL},
+	 { (char *)"SVertex_shape", _wrap_SVertex_shape, METH_VARARGS, NULL},
+	 { (char *)"SVertex_shape_importance", _wrap_SVertex_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"SVertex_qi", _wrap_SVertex_qi, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occluders_begin", _wrap_SVertex_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occluders_end", _wrap_SVertex_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occluders_empty", _wrap_SVertex_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occluders_size", _wrap_SVertex_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occludee", _wrap_SVertex_occludee, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occluded_shape", _wrap_SVertex_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"SVertex_occludee_empty", _wrap_SVertex_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"SVertex_z_discontinuity", _wrap_SVertex_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"SVertex_swigregister", SVertex_swigregister, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getExactTypeName", _wrap_FEdge_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getLength2D", _wrap_FEdge_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getId", _wrap_FEdge_getId, METH_VARARGS, NULL},
+	 { (char *)"FEdge_userdata_set", _wrap_FEdge_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"FEdge_userdata_get", _wrap_FEdge_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_FEdge", _wrap_new_FEdge, METH_VARARGS, NULL},
+	 { (char *)"delete_FEdge", _wrap_delete_FEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_duplicate", _wrap_FEdge_duplicate, METH_VARARGS, NULL},
+	 { (char *)"FEdge_vertexA", _wrap_FEdge_vertexA, METH_VARARGS, NULL},
+	 { (char *)"FEdge_vertexB", _wrap_FEdge_vertexB, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getNature", _wrap_FEdge_getNature, METH_VARARGS, NULL},
+	 { (char *)"FEdge_nextEdge", _wrap_FEdge_nextEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_previousEdge", _wrap_FEdge_previousEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_invisibility", _wrap_FEdge_invisibility, METH_VARARGS, NULL},
+	 { (char *)"FEdge_viewedge", _wrap_FEdge_viewedge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_center3d", _wrap_FEdge_center3d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_center2d", _wrap_FEdge_center2d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_aFace", _wrap_FEdge_aFace, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getOccludeeIntersection", _wrap_FEdge_getOccludeeIntersection, METH_VARARGS, NULL},
+	 { (char *)"FEdge_getOccludeeEmpty", _wrap_FEdge_getOccludeeEmpty, METH_VARARGS, NULL},
+	 { (char *)"FEdge_isSmooth", _wrap_FEdge_isSmooth, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setVertexA", _wrap_FEdge_setVertexA, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setVertexB", _wrap_FEdge_setVertexB, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setId", _wrap_FEdge_setId, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setNextEdge", _wrap_FEdge_setNextEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setPreviousEdge", _wrap_FEdge_setPreviousEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setNature", _wrap_FEdge_setNature, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setViewEdge", _wrap_FEdge_setViewEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setaFace", _wrap_FEdge_setaFace, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setOccludeeIntersection", _wrap_FEdge_setOccludeeIntersection, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setOccludeeEmpty", _wrap_FEdge_setOccludeeEmpty, METH_VARARGS, NULL},
+	 { (char *)"FEdge_setSmooth", _wrap_FEdge_setSmooth, METH_VARARGS, NULL},
+	 { (char *)"FEdge_CommonVertex", _wrap_FEdge_CommonVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdge_min2d", _wrap_FEdge_min2d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_max2d", _wrap_FEdge_max2d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_shape_id", _wrap_FEdge_shape_id, METH_VARARGS, NULL},
+	 { (char *)"FEdge_shape", _wrap_FEdge_shape, METH_VARARGS, NULL},
+	 { (char *)"FEdge_shape_importance", _wrap_FEdge_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"FEdge_qi", _wrap_FEdge_qi, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occluders_begin", _wrap_FEdge_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occluders_end", _wrap_FEdge_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occluders_empty", _wrap_FEdge_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occluders_size", _wrap_FEdge_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occludee", _wrap_FEdge_occludee, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occluded_shape", _wrap_FEdge_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"FEdge_occludee_empty", _wrap_FEdge_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"FEdge_z_discontinuity", _wrap_FEdge_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"FEdge_viewedge_nature", _wrap_FEdge_viewedge_nature, METH_VARARGS, NULL},
+	 { (char *)"FEdge_orientation2d", _wrap_FEdge_orientation2d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_orientation3d", _wrap_FEdge_orientation3d, METH_VARARGS, NULL},
+	 { (char *)"FEdge_verticesBegin", _wrap_FEdge_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"FEdge_verticesEnd", _wrap_FEdge_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"FEdge_pointsBegin", _wrap_FEdge_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"FEdge_pointsEnd", _wrap_FEdge_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"FEdge_swigregister", FEdge_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FEdgeSVertexIterator", _wrap_new_FEdgeSVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getExactTypeName", _wrap_FEdgeSVertexIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getObject", _wrap_FEdgeSVertexIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator___deref__", _wrap_FEdgeSVertexIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_increment", _wrap_FEdgeSVertexIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_decrement", _wrap_FEdgeSVertexIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_isBegin", _wrap_FEdgeSVertexIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_isEnd", _wrap_FEdgeSVertexIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator___eq__", _wrap_FEdgeSVertexIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_t", _wrap_FEdgeSVertexIterator_t, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_u", _wrap_FEdgeSVertexIterator_u, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_copy", _wrap_FEdgeSVertexIterator_copy, METH_VARARGS, NULL},
+	 { (char *)"delete_FEdgeSVertexIterator", _wrap_delete_FEdgeSVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getX", _wrap_FEdgeSVertexIterator_getX, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getY", _wrap_FEdgeSVertexIterator_getY, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getZ", _wrap_FEdgeSVertexIterator_getZ, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getPoint3D", _wrap_FEdgeSVertexIterator_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getProjectedX", _wrap_FEdgeSVertexIterator_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getProjectedY", _wrap_FEdgeSVertexIterator_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getProjectedZ", _wrap_FEdgeSVertexIterator_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getPoint2D", _wrap_FEdgeSVertexIterator_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getFEdge", _wrap_FEdgeSVertexIterator_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getId", _wrap_FEdgeSVertexIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getNature", _wrap_FEdgeSVertexIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_castToSVertex", _wrap_FEdgeSVertexIterator_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_castToViewVertex", _wrap_FEdgeSVertexIterator_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_castToNonTVertex", _wrap_FEdgeSVertexIterator_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_castToTVertex", _wrap_FEdgeSVertexIterator_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_userdata_set", _wrap_FEdgeSVertexIterator_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_userdata_get", _wrap_FEdgeSVertexIterator_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_duplicate", _wrap_FEdgeSVertexIterator_duplicate, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_point3D", _wrap_FEdgeSVertexIterator_point3D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_point2D", _wrap_FEdgeSVertexIterator_point2D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_normals", _wrap_FEdgeSVertexIterator_normals, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_normalsSize", _wrap_FEdgeSVertexIterator_normalsSize, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_fedges", _wrap_FEdgeSVertexIterator_fedges, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_fedges_begin", _wrap_FEdgeSVertexIterator_fedges_begin, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_fedges_end", _wrap_FEdgeSVertexIterator_fedges_end, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_shape", _wrap_FEdgeSVertexIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_z", _wrap_FEdgeSVertexIterator_z, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_viewvertex", _wrap_FEdgeSVertexIterator_viewvertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setPoint3D", _wrap_FEdgeSVertexIterator_setPoint3D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setPoint2D", _wrap_FEdgeSVertexIterator_setPoint2D, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_AddNormal", _wrap_FEdgeSVertexIterator_AddNormal, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setCurvatureInfo", _wrap_FEdgeSVertexIterator_setCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_getCurvatureInfo", _wrap_FEdgeSVertexIterator_getCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setCurvatureFredo", _wrap_FEdgeSVertexIterator_setCurvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setDirectionFredo", _wrap_FEdgeSVertexIterator_setDirectionFredo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_curvatureFredo", _wrap_FEdgeSVertexIterator_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_directionFredo", _wrap_FEdgeSVertexIterator_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setId", _wrap_FEdgeSVertexIterator_setId, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setFEdges", _wrap_FEdgeSVertexIterator_setFEdges, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setShape", _wrap_FEdgeSVertexIterator_setShape, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_setViewVertex", _wrap_FEdgeSVertexIterator_setViewVertex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_AddFEdge", _wrap_FEdgeSVertexIterator_AddFEdge, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_Replace", _wrap_FEdgeSVertexIterator_Replace, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_fedge", _wrap_FEdgeSVertexIterator_fedge, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_point2d", _wrap_FEdgeSVertexIterator_point2d, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_point3d", _wrap_FEdgeSVertexIterator_point3d, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_normal", _wrap_FEdgeSVertexIterator_normal, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_shape_id", _wrap_FEdgeSVertexIterator_shape_id, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_shape_importance", _wrap_FEdgeSVertexIterator_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_qi", _wrap_FEdgeSVertexIterator_qi, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occluders_begin", _wrap_FEdgeSVertexIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occluders_end", _wrap_FEdgeSVertexIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occluders_empty", _wrap_FEdgeSVertexIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occluders_size", _wrap_FEdgeSVertexIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occludee", _wrap_FEdgeSVertexIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occluded_shape", _wrap_FEdgeSVertexIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_occludee_empty", _wrap_FEdgeSVertexIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_z_discontinuity", _wrap_FEdgeSVertexIterator_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSVertexIterator_swigregister", FEdgeSVertexIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FEdgeSharp", _wrap_new_FEdgeSharp, METH_VARARGS, NULL},
+	 { (char *)"delete_FEdgeSharp", _wrap_delete_FEdgeSharp, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_duplicate", _wrap_FEdgeSharp_duplicate, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_normalA", _wrap_FEdgeSharp_normalA, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_normalB", _wrap_FEdgeSharp_normalB, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_aMaterialIndex", _wrap_FEdgeSharp_aMaterialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_aMaterial", _wrap_FEdgeSharp_aMaterial, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_bMaterialIndex", _wrap_FEdgeSharp_bMaterialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_bMaterial", _wrap_FEdgeSharp_bMaterial, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_setNormalA", _wrap_FEdgeSharp_setNormalA, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_setNormalB", _wrap_FEdgeSharp_setNormalB, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_setaMaterialIndex", _wrap_FEdgeSharp_setaMaterialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_setbMaterialIndex", _wrap_FEdgeSharp_setbMaterialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSharp_swigregister", FEdgeSharp_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FEdgeSmooth", _wrap_new_FEdgeSmooth, METH_VARARGS, NULL},
+	 { (char *)"delete_FEdgeSmooth", _wrap_delete_FEdgeSmooth, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_duplicate", _wrap_FEdgeSmooth_duplicate, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_face", _wrap_FEdgeSmooth_face, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_normal", _wrap_FEdgeSmooth_normal, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_materialIndex", _wrap_FEdgeSmooth_materialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_material", _wrap_FEdgeSmooth_material, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_setFace", _wrap_FEdgeSmooth_setFace, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_setNormal", _wrap_FEdgeSmooth_setNormal, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_setMaterialIndex", _wrap_FEdgeSmooth_setMaterialIndex, METH_VARARGS, NULL},
+	 { (char *)"FEdgeSmooth_swigregister", FEdgeSmooth_swigregister, METH_VARARGS, NULL},
+	 { (char *)"SShape_userdata_set", _wrap_SShape_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"SShape_userdata_get", _wrap_SShape_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_SShape", _wrap_new_SShape, METH_VARARGS, NULL},
+	 { (char *)"SShape_duplicate", _wrap_SShape_duplicate, METH_VARARGS, NULL},
+	 { (char *)"delete_SShape", _wrap_delete_SShape, METH_VARARGS, NULL},
+	 { (char *)"SShape_AddEdge", _wrap_SShape_AddEdge, METH_VARARGS, NULL},
+	 { (char *)"SShape_AddNewVertex", _wrap_SShape_AddNewVertex, METH_VARARGS, NULL},
+	 { (char *)"SShape_AddChain", _wrap_SShape_AddChain, METH_VARARGS, NULL},
+	 { (char *)"SShape_CreateSVertex", _wrap_SShape_CreateSVertex, METH_VARARGS, NULL},
+	 { (char *)"SShape_SplitEdge", _wrap_SShape_SplitEdge, METH_VARARGS, NULL},
+	 { (char *)"SShape_SplitEdgeIn2", _wrap_SShape_SplitEdgeIn2, METH_VARARGS, NULL},
+	 { (char *)"SShape_setBBox", _wrap_SShape_setBBox, METH_VARARGS, NULL},
+	 { (char *)"SShape_ComputeBBox", _wrap_SShape_ComputeBBox, METH_VARARGS, NULL},
+	 { (char *)"SShape_RemoveEdgeFromChain", _wrap_SShape_RemoveEdgeFromChain, METH_VARARGS, NULL},
+	 { (char *)"SShape_RemoveEdge", _wrap_SShape_RemoveEdge, METH_VARARGS, NULL},
+	 { (char *)"SShape_GetVertexList", _wrap_SShape_GetVertexList, METH_VARARGS, NULL},
+	 { (char *)"SShape_GetEdgeList", _wrap_SShape_GetEdgeList, METH_VARARGS, NULL},
+	 { (char *)"SShape_GetChains", _wrap_SShape_GetChains, METH_VARARGS, NULL},
+	 { (char *)"SShape_bbox", _wrap_SShape_bbox, METH_VARARGS, NULL},
+	 { (char *)"SShape_material", _wrap_SShape_material, METH_VARARGS, NULL},
+	 { (char *)"SShape_materials", _wrap_SShape_materials, METH_VARARGS, NULL},
+	 { (char *)"SShape_viewShape", _wrap_SShape_viewShape, METH_VARARGS, NULL},
+	 { (char *)"SShape_importance", _wrap_SShape_importance, METH_VARARGS, NULL},
+	 { (char *)"SShape_getId", _wrap_SShape_getId, METH_VARARGS, NULL},
+	 { (char *)"SShape_setId", _wrap_SShape_setId, METH_VARARGS, NULL},
+	 { (char *)"SShape_setMaterials", _wrap_SShape_setMaterials, METH_VARARGS, NULL},
+	 { (char *)"SShape_setViewShape", _wrap_SShape_setViewShape, METH_VARARGS, NULL},
+	 { (char *)"SShape_setImportance", _wrap_SShape_setImportance, METH_VARARGS, NULL},
+	 { (char *)"SShape_swigregister", SShape_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_iterator", _wrap_ViewShapesContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___nonzero__", _wrap_ViewShapesContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___len__", _wrap_ViewShapesContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_pop", _wrap_ViewShapesContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___getslice__", _wrap_ViewShapesContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___setslice__", _wrap_ViewShapesContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___delslice__", _wrap_ViewShapesContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___delitem__", _wrap_ViewShapesContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___getitem__", _wrap_ViewShapesContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer___setitem__", _wrap_ViewShapesContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_append", _wrap_ViewShapesContainer_append, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_empty", _wrap_ViewShapesContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_size", _wrap_ViewShapesContainer_size, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_clear", _wrap_ViewShapesContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_swap", _wrap_ViewShapesContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_get_allocator", _wrap_ViewShapesContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_begin", _wrap_ViewShapesContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_end", _wrap_ViewShapesContainer_end, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_rbegin", _wrap_ViewShapesContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_rend", _wrap_ViewShapesContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_pop_back", _wrap_ViewShapesContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_erase", _wrap_ViewShapesContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_ViewShapesContainer", _wrap_new_ViewShapesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_push_back", _wrap_ViewShapesContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_front", _wrap_ViewShapesContainer_front, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_back", _wrap_ViewShapesContainer_back, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_assign", _wrap_ViewShapesContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_resize", _wrap_ViewShapesContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_insert", _wrap_ViewShapesContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_reserve", _wrap_ViewShapesContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_capacity", _wrap_ViewShapesContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewShapesContainer", _wrap_delete_ViewShapesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewShapesContainer_swigregister", ViewShapesContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_iterator", _wrap_ViewEdgesContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___nonzero__", _wrap_ViewEdgesContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___len__", _wrap_ViewEdgesContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_pop", _wrap_ViewEdgesContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___getslice__", _wrap_ViewEdgesContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___setslice__", _wrap_ViewEdgesContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___delslice__", _wrap_ViewEdgesContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___delitem__", _wrap_ViewEdgesContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___getitem__", _wrap_ViewEdgesContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer___setitem__", _wrap_ViewEdgesContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_append", _wrap_ViewEdgesContainer_append, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_empty", _wrap_ViewEdgesContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_size", _wrap_ViewEdgesContainer_size, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_clear", _wrap_ViewEdgesContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_swap", _wrap_ViewEdgesContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_get_allocator", _wrap_ViewEdgesContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_begin", _wrap_ViewEdgesContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_end", _wrap_ViewEdgesContainer_end, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_rbegin", _wrap_ViewEdgesContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_rend", _wrap_ViewEdgesContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_pop_back", _wrap_ViewEdgesContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_erase", _wrap_ViewEdgesContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_ViewEdgesContainer", _wrap_new_ViewEdgesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_push_back", _wrap_ViewEdgesContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_front", _wrap_ViewEdgesContainer_front, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_back", _wrap_ViewEdgesContainer_back, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_assign", _wrap_ViewEdgesContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_resize", _wrap_ViewEdgesContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_insert", _wrap_ViewEdgesContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_reserve", _wrap_ViewEdgesContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_capacity", _wrap_ViewEdgesContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewEdgesContainer", _wrap_delete_ViewEdgesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgesContainer_swigregister", ViewEdgesContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_iterator", _wrap_FEdgesContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___nonzero__", _wrap_FEdgesContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___len__", _wrap_FEdgesContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_pop", _wrap_FEdgesContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___getslice__", _wrap_FEdgesContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___setslice__", _wrap_FEdgesContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___delslice__", _wrap_FEdgesContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___delitem__", _wrap_FEdgesContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___getitem__", _wrap_FEdgesContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer___setitem__", _wrap_FEdgesContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_append", _wrap_FEdgesContainer_append, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_empty", _wrap_FEdgesContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_size", _wrap_FEdgesContainer_size, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_clear", _wrap_FEdgesContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_swap", _wrap_FEdgesContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_get_allocator", _wrap_FEdgesContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_begin", _wrap_FEdgesContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_end", _wrap_FEdgesContainer_end, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_rbegin", _wrap_FEdgesContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_rend", _wrap_FEdgesContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_pop_back", _wrap_FEdgesContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_erase", _wrap_FEdgesContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_FEdgesContainer", _wrap_new_FEdgesContainer, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_push_back", _wrap_FEdgesContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_front", _wrap_FEdgesContainer_front, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_back", _wrap_FEdgesContainer_back, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_assign", _wrap_FEdgesContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_resize", _wrap_FEdgesContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_insert", _wrap_FEdgesContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_reserve", _wrap_FEdgesContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_capacity", _wrap_FEdgesContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_FEdgesContainer", _wrap_delete_FEdgesContainer, METH_VARARGS, NULL},
+	 { (char *)"FEdgesContainer_swigregister", FEdgesContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_iterator", _wrap_ViewVerticesContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___nonzero__", _wrap_ViewVerticesContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___len__", _wrap_ViewVerticesContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_pop", _wrap_ViewVerticesContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___getslice__", _wrap_ViewVerticesContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___setslice__", _wrap_ViewVerticesContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___delslice__", _wrap_ViewVerticesContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___delitem__", _wrap_ViewVerticesContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___getitem__", _wrap_ViewVerticesContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer___setitem__", _wrap_ViewVerticesContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_append", _wrap_ViewVerticesContainer_append, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_empty", _wrap_ViewVerticesContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_size", _wrap_ViewVerticesContainer_size, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_clear", _wrap_ViewVerticesContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_swap", _wrap_ViewVerticesContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_get_allocator", _wrap_ViewVerticesContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_begin", _wrap_ViewVerticesContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_end", _wrap_ViewVerticesContainer_end, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_rbegin", _wrap_ViewVerticesContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_rend", _wrap_ViewVerticesContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_pop_back", _wrap_ViewVerticesContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_erase", _wrap_ViewVerticesContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_ViewVerticesContainer", _wrap_new_ViewVerticesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_push_back", _wrap_ViewVerticesContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_front", _wrap_ViewVerticesContainer_front, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_back", _wrap_ViewVerticesContainer_back, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_assign", _wrap_ViewVerticesContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_resize", _wrap_ViewVerticesContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_insert", _wrap_ViewVerticesContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_reserve", _wrap_ViewVerticesContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_capacity", _wrap_ViewVerticesContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewVerticesContainer", _wrap_delete_ViewVerticesContainer, METH_VARARGS, NULL},
+	 { (char *)"ViewVerticesContainer_swigregister", ViewVerticesContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_iterator", _wrap_SVerticesContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___nonzero__", _wrap_SVerticesContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___len__", _wrap_SVerticesContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_pop", _wrap_SVerticesContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___getslice__", _wrap_SVerticesContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___setslice__", _wrap_SVerticesContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___delslice__", _wrap_SVerticesContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___delitem__", _wrap_SVerticesContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___getitem__", _wrap_SVerticesContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer___setitem__", _wrap_SVerticesContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_append", _wrap_SVerticesContainer_append, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_empty", _wrap_SVerticesContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_size", _wrap_SVerticesContainer_size, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_clear", _wrap_SVerticesContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_swap", _wrap_SVerticesContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_get_allocator", _wrap_SVerticesContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_begin", _wrap_SVerticesContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_end", _wrap_SVerticesContainer_end, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_rbegin", _wrap_SVerticesContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_rend", _wrap_SVerticesContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_pop_back", _wrap_SVerticesContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_erase", _wrap_SVerticesContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_SVerticesContainer", _wrap_new_SVerticesContainer, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_push_back", _wrap_SVerticesContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_front", _wrap_SVerticesContainer_front, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_back", _wrap_SVerticesContainer_back, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_assign", _wrap_SVerticesContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_resize", _wrap_SVerticesContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_insert", _wrap_SVerticesContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_reserve", _wrap_SVerticesContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_capacity", _wrap_SVerticesContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_SVerticesContainer", _wrap_delete_SVerticesContainer, METH_VARARGS, NULL},
+	 { (char *)"SVerticesContainer_swigregister", SVerticesContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_userdata_set", _wrap_ViewMap_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_userdata_get", _wrap_ViewMap_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_ViewMap", _wrap_new_ViewMap, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewMap", _wrap_delete_ViewMap, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_GetClosestViewEdge", _wrap_ViewMap_GetClosestViewEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_GetClosestFEdge", _wrap_ViewMap_GetClosestFEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_getInstance", _wrap_ViewMap_getInstance, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_ViewShapes", _wrap_ViewMap_ViewShapes, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_ViewEdges", _wrap_ViewMap_ViewEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_ViewVertices", _wrap_ViewMap_ViewVertices, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_FEdges", _wrap_ViewMap_FEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_SVertices", _wrap_ViewMap_SVertices, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_viewedges_begin", _wrap_ViewMap_viewedges_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_viewedges_end", _wrap_ViewMap_viewedges_end, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_viewedges_size", _wrap_ViewMap_viewedges_size, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_viewShape", _wrap_ViewMap_viewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_shapeIdToIndexMap", _wrap_ViewMap_shapeIdToIndexMap, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_getScene3dBBox", _wrap_ViewMap_getScene3dBBox, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_AddViewShape", _wrap_ViewMap_AddViewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_AddViewEdge", _wrap_ViewMap_AddViewEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_AddViewVertex", _wrap_ViewMap_AddViewVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_AddFEdge", _wrap_ViewMap_AddFEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_AddSVertex", _wrap_ViewMap_AddSVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_setScene3dBBox", _wrap_ViewMap_setScene3dBBox, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_CreateTVertex", _wrap_ViewMap_CreateTVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_InsertViewVertex", _wrap_ViewMap_InsertViewVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewMap_swigregister", ViewMap_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_getExactTypeName", _wrap_ViewVertex_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_userdata_set", _wrap_ViewVertex_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_userdata_get", _wrap_ViewVertex_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewVertex", _wrap_delete_ViewVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_getNature", _wrap_ViewVertex_getNature, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_setNature", _wrap_ViewVertex_setNature, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_Replace", _wrap_ViewVertex_Replace, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edges_begin", _wrap_ViewVertex_edges_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edges_end", _wrap_ViewVertex_edges_end, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edges_iterator", _wrap_ViewVertex_edges_iterator, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edgesBegin", _wrap_ViewVertex_edgesBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edgesEnd", _wrap_ViewVertex_edgesEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_edgesIterator", _wrap_ViewVertex_edgesIterator, METH_VARARGS, NULL},
+	 { (char *)"ViewVertex_swigregister", ViewVertex_swigregister, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getExactTypeName", _wrap_TVertex_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getX", _wrap_TVertex_getX, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getY", _wrap_TVertex_getY, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getZ", _wrap_TVertex_getZ, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getPoint3D", _wrap_TVertex_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getProjectedX", _wrap_TVertex_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getProjectedY", _wrap_TVertex_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getProjectedZ", _wrap_TVertex_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getPoint2D", _wrap_TVertex_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"TVertex_getId", _wrap_TVertex_getId, METH_VARARGS, NULL},
+	 { (char *)"TVertex_castToViewVertex", _wrap_TVertex_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_castToTVertex", _wrap_TVertex_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"new_TVertex", _wrap_new_TVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_frontSVertex", _wrap_TVertex_frontSVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_backSVertex", _wrap_TVertex_backSVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_frontEdgeA", _wrap_TVertex_frontEdgeA, METH_VARARGS, NULL},
+	 { (char *)"TVertex_frontEdgeB", _wrap_TVertex_frontEdgeB, METH_VARARGS, NULL},
+	 { (char *)"TVertex_backEdgeA", _wrap_TVertex_backEdgeA, METH_VARARGS, NULL},
+	 { (char *)"TVertex_backEdgeB", _wrap_TVertex_backEdgeB, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setFrontVertex", _wrap_TVertex_setFrontVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setBackSVertex", _wrap_TVertex_setBackSVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setFrontEdgeA", _wrap_TVertex_setFrontEdgeA, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setFrontEdgeB", _wrap_TVertex_setFrontEdgeB, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setBackEdgeA", _wrap_TVertex_setBackEdgeA, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setBackEdgeB", _wrap_TVertex_setBackEdgeB, METH_VARARGS, NULL},
+	 { (char *)"TVertex_setId", _wrap_TVertex_setId, METH_VARARGS, NULL},
+	 { (char *)"TVertex_GetSVertex", _wrap_TVertex_GetSVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_Replace", _wrap_TVertex_Replace, METH_VARARGS, NULL},
+	 { (char *)"TVertex_mate", _wrap_TVertex_mate, METH_VARARGS, NULL},
+	 { (char *)"TVertex_edges_end", _wrap_TVertex_edges_end, METH_VARARGS, NULL},
+	 { (char *)"TVertex_edgesBegin", _wrap_TVertex_edgesBegin, METH_VARARGS, NULL},
+	 { (char *)"TVertex_edgesEnd", _wrap_TVertex_edgesEnd, METH_VARARGS, NULL},
+	 { (char *)"TVertex_edgesIterator", _wrap_TVertex_edgesIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_TVertex", _wrap_delete_TVertex, METH_VARARGS, NULL},
+	 { (char *)"TVertex_swigregister", TVertex_swigregister, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getExactTypeName", _wrap_NonTVertex_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getX", _wrap_NonTVertex_getX, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getY", _wrap_NonTVertex_getY, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getZ", _wrap_NonTVertex_getZ, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getPoint3D", _wrap_NonTVertex_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getProjectedX", _wrap_NonTVertex_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getProjectedY", _wrap_NonTVertex_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getProjectedZ", _wrap_NonTVertex_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getPoint2D", _wrap_NonTVertex_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_getId", _wrap_NonTVertex_getId, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_castToSVertex", _wrap_NonTVertex_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_castToViewVertex", _wrap_NonTVertex_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_castToNonTVertex", _wrap_NonTVertex_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"new_NonTVertex", _wrap_new_NonTVertex, METH_VARARGS, NULL},
+	 { (char *)"delete_NonTVertex", _wrap_delete_NonTVertex, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_svertex", _wrap_NonTVertex_svertex, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_viewedges", _wrap_NonTVertex_viewedges, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_setSVertex", _wrap_NonTVertex_setSVertex, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_setViewEdges", _wrap_NonTVertex_setViewEdges, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_AddIncomingViewEdge", _wrap_NonTVertex_AddIncomingViewEdge, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_AddOutgoingViewEdge", _wrap_NonTVertex_AddOutgoingViewEdge, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_AddViewEdge", _wrap_NonTVertex_AddViewEdge, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_Replace", _wrap_NonTVertex_Replace, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_edges_end", _wrap_NonTVertex_edges_end, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_edgesBegin", _wrap_NonTVertex_edgesBegin, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_edgesEnd", _wrap_NonTVertex_edgesEnd, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_edgesIterator", _wrap_NonTVertex_edgesIterator, METH_VARARGS, NULL},
+	 { (char *)"NonTVertex_swigregister", NonTVertex_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_getExactTypeName", _wrap_ViewEdge_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_getId", _wrap_ViewEdge_getId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_getNature", _wrap_ViewEdge_getNature, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_userdata_set", _wrap_ViewEdge_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_userdata_get", _wrap_ViewEdge_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_ViewEdge", _wrap_new_ViewEdge, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewEdge", _wrap_delete_ViewEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_A", _wrap_ViewEdge_A, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_B", _wrap_ViewEdge_B, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_fedgeA", _wrap_ViewEdge_fedgeA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_fedgeB", _wrap_ViewEdge_fedgeB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_viewShape", _wrap_ViewEdge_viewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_isClosed", _wrap_ViewEdge_isClosed, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_getChainingTimeStamp", _wrap_ViewEdge_getChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_aShape", _wrap_ViewEdge_aShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_bShape", _wrap_ViewEdge_bShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluders", _wrap_ViewEdge_occluders, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_splittingId", _wrap_ViewEdge_splittingId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setA", _wrap_ViewEdge_setA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setB", _wrap_ViewEdge_setB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setNature", _wrap_ViewEdge_setNature, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setFEdgeA", _wrap_ViewEdge_setFEdgeA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setFEdgeB", _wrap_ViewEdge_setFEdgeB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setShape", _wrap_ViewEdge_setShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setId", _wrap_ViewEdge_setId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_UpdateFEdges", _wrap_ViewEdge_UpdateFEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setaShape", _wrap_ViewEdge_setaShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setQI", _wrap_ViewEdge_setQI, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setChainingTimeStamp", _wrap_ViewEdge_setChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_AddOccluder", _wrap_ViewEdge_AddOccluder, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_setSplittingId", _wrap_ViewEdge_setSplittingId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_intersect_2d_area", _wrap_ViewEdge_intersect_2d_area, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_include_in_2d_area", _wrap_ViewEdge_include_in_2d_area, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_getLength2D", _wrap_ViewEdge_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_qi", _wrap_ViewEdge_qi, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluders_begin", _wrap_ViewEdge_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluders_end", _wrap_ViewEdge_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluders_size", _wrap_ViewEdge_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluders_empty", _wrap_ViewEdge_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occludee", _wrap_ViewEdge_occludee, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occluded_shape", _wrap_ViewEdge_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_occludee_empty", _wrap_ViewEdge_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_shape_id", _wrap_ViewEdge_shape_id, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_shape", _wrap_ViewEdge_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_shape_importance", _wrap_ViewEdge_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_verticesBegin", _wrap_ViewEdge_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_verticesEnd", _wrap_ViewEdge_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_pointsBegin", _wrap_ViewEdge_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_pointsEnd", _wrap_ViewEdge_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdge_swigregister", ViewEdge_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_userdata_set", _wrap_ViewShape_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_userdata_get", _wrap_ViewShape_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"new_ViewShape", _wrap_new_ViewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_duplicate", _wrap_ViewShape_duplicate, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewShape", _wrap_delete_ViewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_SplitEdge", _wrap_ViewShape_SplitEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_sshape", _wrap_ViewShape_sshape, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_vertices", _wrap_ViewShape_vertices, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_edges", _wrap_ViewShape_edges, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_getId", _wrap_ViewShape_getId, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_setSShape", _wrap_ViewShape_setSShape, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_setVertices", _wrap_ViewShape_setVertices, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_setEdges", _wrap_ViewShape_setEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_AddVertex", _wrap_ViewShape_AddVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_AddEdge", _wrap_ViewShape_AddEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_RemoveEdge", _wrap_ViewShape_RemoveEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_RemoveVertex", _wrap_ViewShape_RemoveVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewShape_swigregister", ViewShape_swigregister, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewVertexOrientedViewEdgeIterator", _wrap_delete_ViewVertexOrientedViewEdgeIterator, METH_VARARGS, NULL},
+	 { (char *)"new_ViewVertexOrientedViewEdgeIterator", _wrap_new_ViewVertexOrientedViewEdgeIterator, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator_isBegin", _wrap_ViewVertexOrientedViewEdgeIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator_isEnd", _wrap_ViewVertexOrientedViewEdgeIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator___ne__", _wrap_ViewVertexOrientedViewEdgeIterator___ne__, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator___eq__", _wrap_ViewVertexOrientedViewEdgeIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator_getObject", _wrap_ViewVertexOrientedViewEdgeIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator___deref__", _wrap_ViewVertexOrientedViewEdgeIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator_increment", _wrap_ViewVertexOrientedViewEdgeIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"ViewVertexOrientedViewEdgeIterator_swigregister", ViewVertexOrientedViewEdgeIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ViewEdgeSVertexIterator", _wrap_new_ViewEdgeSVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewEdgeSVertexIterator", _wrap_delete_ViewEdgeSVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getExactTypeName", _wrap_ViewEdgeSVertexIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getObject", _wrap_ViewEdgeSVertexIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator___deref__", _wrap_ViewEdgeSVertexIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_increment", _wrap_ViewEdgeSVertexIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_decrement", _wrap_ViewEdgeSVertexIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_isBegin", _wrap_ViewEdgeSVertexIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_isEnd", _wrap_ViewEdgeSVertexIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_t", _wrap_ViewEdgeSVertexIterator_t, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_u", _wrap_ViewEdgeSVertexIterator_u, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator___eq__", _wrap_ViewEdgeSVertexIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_copy", _wrap_ViewEdgeSVertexIterator_copy, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getX", _wrap_ViewEdgeSVertexIterator_getX, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getY", _wrap_ViewEdgeSVertexIterator_getY, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getZ", _wrap_ViewEdgeSVertexIterator_getZ, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getPoint3D", _wrap_ViewEdgeSVertexIterator_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getProjectedX", _wrap_ViewEdgeSVertexIterator_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getProjectedY", _wrap_ViewEdgeSVertexIterator_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getProjectedZ", _wrap_ViewEdgeSVertexIterator_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getPoint2D", _wrap_ViewEdgeSVertexIterator_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getFEdge", _wrap_ViewEdgeSVertexIterator_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getId", _wrap_ViewEdgeSVertexIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getNature", _wrap_ViewEdgeSVertexIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_castToSVertex", _wrap_ViewEdgeSVertexIterator_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_castToViewVertex", _wrap_ViewEdgeSVertexIterator_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_castToNonTVertex", _wrap_ViewEdgeSVertexIterator_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_castToTVertex", _wrap_ViewEdgeSVertexIterator_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_userdata_set", _wrap_ViewEdgeSVertexIterator_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_userdata_get", _wrap_ViewEdgeSVertexIterator_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_duplicate", _wrap_ViewEdgeSVertexIterator_duplicate, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_point3D", _wrap_ViewEdgeSVertexIterator_point3D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_point2D", _wrap_ViewEdgeSVertexIterator_point2D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_normals", _wrap_ViewEdgeSVertexIterator_normals, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_normalsSize", _wrap_ViewEdgeSVertexIterator_normalsSize, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_fedges", _wrap_ViewEdgeSVertexIterator_fedges, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_fedges_begin", _wrap_ViewEdgeSVertexIterator_fedges_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_fedges_end", _wrap_ViewEdgeSVertexIterator_fedges_end, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_shape", _wrap_ViewEdgeSVertexIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_z", _wrap_ViewEdgeSVertexIterator_z, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_viewvertex", _wrap_ViewEdgeSVertexIterator_viewvertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setPoint3D", _wrap_ViewEdgeSVertexIterator_setPoint3D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setPoint2D", _wrap_ViewEdgeSVertexIterator_setPoint2D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_AddNormal", _wrap_ViewEdgeSVertexIterator_AddNormal, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setCurvatureInfo", _wrap_ViewEdgeSVertexIterator_setCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_getCurvatureInfo", _wrap_ViewEdgeSVertexIterator_getCurvatureInfo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setCurvatureFredo", _wrap_ViewEdgeSVertexIterator_setCurvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setDirectionFredo", _wrap_ViewEdgeSVertexIterator_setDirectionFredo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_curvatureFredo", _wrap_ViewEdgeSVertexIterator_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_directionFredo", _wrap_ViewEdgeSVertexIterator_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setId", _wrap_ViewEdgeSVertexIterator_setId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setFEdges", _wrap_ViewEdgeSVertexIterator_setFEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setShape", _wrap_ViewEdgeSVertexIterator_setShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_setViewVertex", _wrap_ViewEdgeSVertexIterator_setViewVertex, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_AddFEdge", _wrap_ViewEdgeSVertexIterator_AddFEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_Replace", _wrap_ViewEdgeSVertexIterator_Replace, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_fedge", _wrap_ViewEdgeSVertexIterator_fedge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_point2d", _wrap_ViewEdgeSVertexIterator_point2d, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_point3d", _wrap_ViewEdgeSVertexIterator_point3d, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_normal", _wrap_ViewEdgeSVertexIterator_normal, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_shape_id", _wrap_ViewEdgeSVertexIterator_shape_id, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_shape_importance", _wrap_ViewEdgeSVertexIterator_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_qi", _wrap_ViewEdgeSVertexIterator_qi, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occluders_begin", _wrap_ViewEdgeSVertexIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occluders_end", _wrap_ViewEdgeSVertexIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occluders_empty", _wrap_ViewEdgeSVertexIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occluders_size", _wrap_ViewEdgeSVertexIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occludee", _wrap_ViewEdgeSVertexIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occluded_shape", _wrap_ViewEdgeSVertexIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_occludee_empty", _wrap_ViewEdgeSVertexIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_z_discontinuity", _wrap_ViewEdgeSVertexIterator_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeSVertexIterator_swigregister", ViewEdgeSVertexIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ViewEdgeViewEdgeIterator", _wrap_new_ViewEdgeViewEdgeIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewEdgeViewEdgeIterator", _wrap_delete_ViewEdgeViewEdgeIterator, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getExactTypeName", _wrap_ViewEdgeViewEdgeIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getCurrentEdge", _wrap_ViewEdgeViewEdgeIterator_getCurrentEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setCurrentEdge", _wrap_ViewEdgeViewEdgeIterator_setCurrentEdge, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getBegin", _wrap_ViewEdgeViewEdgeIterator_getBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setBegin", _wrap_ViewEdgeViewEdgeIterator_setBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getOrientation", _wrap_ViewEdgeViewEdgeIterator_getOrientation, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setOrientation", _wrap_ViewEdgeViewEdgeIterator_setOrientation, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_changeOrientation", _wrap_ViewEdgeViewEdgeIterator_changeOrientation, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getObject", _wrap_ViewEdgeViewEdgeIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator___deref__", _wrap_ViewEdgeViewEdgeIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_increment", _wrap_ViewEdgeViewEdgeIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_decrement", _wrap_ViewEdgeViewEdgeIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_isBegin", _wrap_ViewEdgeViewEdgeIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_isEnd", _wrap_ViewEdgeViewEdgeIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator___eq__", _wrap_ViewEdgeViewEdgeIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator___ne__", _wrap_ViewEdgeViewEdgeIterator___ne__, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getId", _wrap_ViewEdgeViewEdgeIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getNature", _wrap_ViewEdgeViewEdgeIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_userdata_set", _wrap_ViewEdgeViewEdgeIterator_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_userdata_get", _wrap_ViewEdgeViewEdgeIterator_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_A", _wrap_ViewEdgeViewEdgeIterator_A, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_B", _wrap_ViewEdgeViewEdgeIterator_B, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_fedgeA", _wrap_ViewEdgeViewEdgeIterator_fedgeA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_fedgeB", _wrap_ViewEdgeViewEdgeIterator_fedgeB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_viewShape", _wrap_ViewEdgeViewEdgeIterator_viewShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_aShape", _wrap_ViewEdgeViewEdgeIterator_aShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_isClosed", _wrap_ViewEdgeViewEdgeIterator_isClosed, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getChainingTimeStamp", _wrap_ViewEdgeViewEdgeIterator_getChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_bShape", _wrap_ViewEdgeViewEdgeIterator_bShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluders", _wrap_ViewEdgeViewEdgeIterator_occluders, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_splittingId", _wrap_ViewEdgeViewEdgeIterator_splittingId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setA", _wrap_ViewEdgeViewEdgeIterator_setA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setB", _wrap_ViewEdgeViewEdgeIterator_setB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setNature", _wrap_ViewEdgeViewEdgeIterator_setNature, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setFEdgeA", _wrap_ViewEdgeViewEdgeIterator_setFEdgeA, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setFEdgeB", _wrap_ViewEdgeViewEdgeIterator_setFEdgeB, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setShape", _wrap_ViewEdgeViewEdgeIterator_setShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setId", _wrap_ViewEdgeViewEdgeIterator_setId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_UpdateFEdges", _wrap_ViewEdgeViewEdgeIterator_UpdateFEdges, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setaShape", _wrap_ViewEdgeViewEdgeIterator_setaShape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setQI", _wrap_ViewEdgeViewEdgeIterator_setQI, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setChainingTimeStamp", _wrap_ViewEdgeViewEdgeIterator_setChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_AddOccluder", _wrap_ViewEdgeViewEdgeIterator_AddOccluder, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setSplittingId", _wrap_ViewEdgeViewEdgeIterator_setSplittingId, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_intersect_2d_area", _wrap_ViewEdgeViewEdgeIterator_intersect_2d_area, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_include_in_2d_area", _wrap_ViewEdgeViewEdgeIterator_include_in_2d_area, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getLength2D", _wrap_ViewEdgeViewEdgeIterator_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_qi", _wrap_ViewEdgeViewEdgeIterator_qi, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluders_begin", _wrap_ViewEdgeViewEdgeIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluders_end", _wrap_ViewEdgeViewEdgeIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluders_size", _wrap_ViewEdgeViewEdgeIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluders_empty", _wrap_ViewEdgeViewEdgeIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occludee", _wrap_ViewEdgeViewEdgeIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occluded_shape", _wrap_ViewEdgeViewEdgeIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_occludee_empty", _wrap_ViewEdgeViewEdgeIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_shape_id", _wrap_ViewEdgeViewEdgeIterator_shape_id, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_shape", _wrap_ViewEdgeViewEdgeIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_shape_importance", _wrap_ViewEdgeViewEdgeIterator_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_verticesBegin", _wrap_ViewEdgeViewEdgeIterator_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_verticesEnd", _wrap_ViewEdgeViewEdgeIterator_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_pointsBegin", _wrap_ViewEdgeViewEdgeIterator_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_pointsEnd", _wrap_ViewEdgeViewEdgeIterator_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_getTimeStamp", _wrap_ViewEdgeViewEdgeIterator_getTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_setTimeStamp", _wrap_ViewEdgeViewEdgeIterator_setTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"disown_ViewEdgeViewEdgeIterator", _wrap_disown_ViewEdgeViewEdgeIterator, METH_VARARGS, NULL},
+	 { (char *)"ViewEdgeViewEdgeIterator_swigregister", ViewEdgeViewEdgeIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DVoid", _wrap_new_UnaryFunction0DVoid, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DVoid", _wrap_delete_UnaryFunction0DVoid, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVoid_getName", _wrap_UnaryFunction0DVoid_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVoid___call__", _wrap_UnaryFunction0DVoid___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DVoid", _wrap_disown_UnaryFunction0DVoid, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVoid_swigregister", UnaryFunction0DVoid_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DUnsigned", _wrap_new_UnaryFunction0DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DUnsigned", _wrap_delete_UnaryFunction0DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DUnsigned_getName", _wrap_UnaryFunction0DUnsigned_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DUnsigned___call__", _wrap_UnaryFunction0DUnsigned___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DUnsigned", _wrap_disown_UnaryFunction0DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DUnsigned_swigregister", UnaryFunction0DUnsigned_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DFloat", _wrap_new_UnaryFunction0DFloat, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DFloat", _wrap_delete_UnaryFunction0DFloat, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DFloat_getName", _wrap_UnaryFunction0DFloat_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DFloat___call__", _wrap_UnaryFunction0DFloat___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DFloat", _wrap_disown_UnaryFunction0DFloat, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DFloat_swigregister", UnaryFunction0DFloat_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DDouble", _wrap_new_UnaryFunction0DDouble, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DDouble", _wrap_delete_UnaryFunction0DDouble, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DDouble_getName", _wrap_UnaryFunction0DDouble_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DDouble___call__", _wrap_UnaryFunction0DDouble___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DDouble", _wrap_disown_UnaryFunction0DDouble, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DDouble_swigregister", UnaryFunction0DDouble_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DVec2f", _wrap_new_UnaryFunction0DVec2f, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DVec2f", _wrap_delete_UnaryFunction0DVec2f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec2f_getName", _wrap_UnaryFunction0DVec2f_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec2f___call__", _wrap_UnaryFunction0DVec2f___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DVec2f", _wrap_disown_UnaryFunction0DVec2f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec2f_swigregister", UnaryFunction0DVec2f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DVec3f", _wrap_new_UnaryFunction0DVec3f, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DVec3f", _wrap_delete_UnaryFunction0DVec3f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec3f_getName", _wrap_UnaryFunction0DVec3f_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec3f___call__", _wrap_UnaryFunction0DVec3f___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DVec3f", _wrap_disown_UnaryFunction0DVec3f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVec3f_swigregister", UnaryFunction0DVec3f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DId", _wrap_new_UnaryFunction0DId, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DId", _wrap_delete_UnaryFunction0DId, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DId_getName", _wrap_UnaryFunction0DId_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DId___call__", _wrap_UnaryFunction0DId___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction0DId", _wrap_disown_UnaryFunction0DId, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DId_swigregister", UnaryFunction0DId_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DViewShape", _wrap_new_UnaryFunction0DViewShape, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DViewShape", _wrap_delete_UnaryFunction0DViewShape, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DViewShape_getName", _wrap_UnaryFunction0DViewShape_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DViewShape___call__", _wrap_UnaryFunction0DViewShape___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DViewShape_swigregister", UnaryFunction0DViewShape_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction0DVectorViewShape", _wrap_new_UnaryFunction0DVectorViewShape, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction0DVectorViewShape", _wrap_delete_UnaryFunction0DVectorViewShape, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVectorViewShape_getName", _wrap_UnaryFunction0DVectorViewShape_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVectorViewShape___call__", _wrap_UnaryFunction0DVectorViewShape___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction0DVectorViewShape_swigregister", UnaryFunction0DVectorViewShape_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetXF0D_getName", _wrap_GetXF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetXF0D___call__", _wrap_GetXF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetXF0D", _wrap_new_GetXF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetXF0D", _wrap_delete_GetXF0D, METH_VARARGS, NULL},
+	 { (char *)"GetXF0D_swigregister", GetXF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetYF0D_getName", _wrap_GetYF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetYF0D___call__", _wrap_GetYF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetYF0D", _wrap_new_GetYF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetYF0D", _wrap_delete_GetYF0D, METH_VARARGS, NULL},
+	 { (char *)"GetYF0D_swigregister", GetYF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetZF0D_getName", _wrap_GetZF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetZF0D___call__", _wrap_GetZF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetZF0D", _wrap_new_GetZF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetZF0D", _wrap_delete_GetZF0D, METH_VARARGS, NULL},
+	 { (char *)"GetZF0D_swigregister", GetZF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF0D_getName", _wrap_GetProjectedXF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF0D___call__", _wrap_GetProjectedXF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedXF0D", _wrap_new_GetProjectedXF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedXF0D", _wrap_delete_GetProjectedXF0D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF0D_swigregister", GetProjectedXF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF0D_getName", _wrap_GetProjectedYF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF0D___call__", _wrap_GetProjectedYF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedYF0D", _wrap_new_GetProjectedYF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedYF0D", _wrap_delete_GetProjectedYF0D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF0D_swigregister", GetProjectedYF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF0D_getName", _wrap_GetProjectedZF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF0D___call__", _wrap_GetProjectedZF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedZF0D", _wrap_new_GetProjectedZF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedZF0D", _wrap_delete_GetProjectedZF0D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF0D_swigregister", GetProjectedZF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetCurvilinearAbscissaF0D_getName", _wrap_GetCurvilinearAbscissaF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetCurvilinearAbscissaF0D___call__", _wrap_GetCurvilinearAbscissaF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetCurvilinearAbscissaF0D", _wrap_new_GetCurvilinearAbscissaF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetCurvilinearAbscissaF0D", _wrap_delete_GetCurvilinearAbscissaF0D, METH_VARARGS, NULL},
+	 { (char *)"GetCurvilinearAbscissaF0D_swigregister", GetCurvilinearAbscissaF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetParameterF0D_getName", _wrap_GetParameterF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetParameterF0D___call__", _wrap_GetParameterF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetParameterF0D", _wrap_new_GetParameterF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetParameterF0D", _wrap_delete_GetParameterF0D, METH_VARARGS, NULL},
+	 { (char *)"GetParameterF0D_swigregister", GetParameterF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation2DF0D_getName", _wrap_VertexOrientation2DF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation2DF0D___call__", _wrap_VertexOrientation2DF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_VertexOrientation2DF0D", _wrap_new_VertexOrientation2DF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_VertexOrientation2DF0D", _wrap_delete_VertexOrientation2DF0D, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation2DF0D_swigregister", VertexOrientation2DF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation3DF0D_getName", _wrap_VertexOrientation3DF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation3DF0D___call__", _wrap_VertexOrientation3DF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_VertexOrientation3DF0D", _wrap_new_VertexOrientation3DF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_VertexOrientation3DF0D", _wrap_delete_VertexOrientation3DF0D, METH_VARARGS, NULL},
+	 { (char *)"VertexOrientation3DF0D_swigregister", VertexOrientation3DF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF0D_getName", _wrap_Curvature2DAngleF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF0D___call__", _wrap_Curvature2DAngleF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_Curvature2DAngleF0D", _wrap_new_Curvature2DAngleF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_Curvature2DAngleF0D", _wrap_delete_Curvature2DAngleF0D, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF0D_swigregister", Curvature2DAngleF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF0D_getName", _wrap_ZDiscontinuityF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF0D___call__", _wrap_ZDiscontinuityF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ZDiscontinuityF0D", _wrap_new_ZDiscontinuityF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_ZDiscontinuityF0D", _wrap_delete_ZDiscontinuityF0D, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF0D_swigregister", ZDiscontinuityF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF0D_getName", _wrap_Normal2DF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF0D___call__", _wrap_Normal2DF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_Normal2DF0D", _wrap_new_Normal2DF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_Normal2DF0D", _wrap_delete_Normal2DF0D, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF0D_swigregister", Normal2DF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"MaterialF0D_getName", _wrap_MaterialF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"MaterialF0D___call__", _wrap_MaterialF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_MaterialF0D", _wrap_new_MaterialF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_MaterialF0D", _wrap_delete_MaterialF0D, METH_VARARGS, NULL},
+	 { (char *)"MaterialF0D_swigregister", MaterialF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ShapeIdF0D_getName", _wrap_ShapeIdF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"ShapeIdF0D___call__", _wrap_ShapeIdF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ShapeIdF0D", _wrap_new_ShapeIdF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_ShapeIdF0D", _wrap_delete_ShapeIdF0D, METH_VARARGS, NULL},
+	 { (char *)"ShapeIdF0D_swigregister", ShapeIdF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF0D_getName", _wrap_QuantitativeInvisibilityF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF0D___call__", _wrap_QuantitativeInvisibilityF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_QuantitativeInvisibilityF0D", _wrap_new_QuantitativeInvisibilityF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_QuantitativeInvisibilityF0D", _wrap_delete_QuantitativeInvisibilityF0D, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF0D_swigregister", QuantitativeInvisibilityF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF0D_getName", _wrap_CurveNatureF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF0D___call__", _wrap_CurveNatureF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_CurveNatureF0D", _wrap_new_CurveNatureF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_CurveNatureF0D", _wrap_delete_CurveNatureF0D, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF0D_swigregister", CurveNatureF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF0D_getName", _wrap_GetShapeF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF0D___call__", _wrap_GetShapeF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetShapeF0D", _wrap_new_GetShapeF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetShapeF0D", _wrap_delete_GetShapeF0D, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF0D_swigregister", GetShapeF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF0D_getName", _wrap_GetOccludersF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF0D___call__", _wrap_GetOccludersF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetOccludersF0D", _wrap_new_GetOccludersF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetOccludersF0D", _wrap_delete_GetOccludersF0D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF0D_swigregister", GetOccludersF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF0D_getName", _wrap_GetOccludeeF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF0D___call__", _wrap_GetOccludeeF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_GetOccludeeF0D", _wrap_new_GetOccludeeF0D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetOccludeeF0D", _wrap_delete_GetOccludeeF0D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF0D_swigregister", GetOccludeeF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"getFEdge", _wrap_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DVoid", _wrap_new_UnaryFunction1DVoid, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DVoid", _wrap_delete_UnaryFunction1DVoid, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVoid_getName", _wrap_UnaryFunction1DVoid_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVoid___call__", _wrap_UnaryFunction1DVoid___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVoid_setIntegrationType", _wrap_UnaryFunction1DVoid_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVoid_getIntegrationType", _wrap_UnaryFunction1DVoid_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DVoid", _wrap_disown_UnaryFunction1DVoid, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVoid_swigregister", UnaryFunction1DVoid_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DUnsigned", _wrap_new_UnaryFunction1DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DUnsigned", _wrap_delete_UnaryFunction1DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DUnsigned_getName", _wrap_UnaryFunction1DUnsigned_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DUnsigned___call__", _wrap_UnaryFunction1DUnsigned___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DUnsigned_setIntegrationType", _wrap_UnaryFunction1DUnsigned_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DUnsigned_getIntegrationType", _wrap_UnaryFunction1DUnsigned_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DUnsigned", _wrap_disown_UnaryFunction1DUnsigned, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DUnsigned_swigregister", UnaryFunction1DUnsigned_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DFloat", _wrap_new_UnaryFunction1DFloat, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DFloat", _wrap_delete_UnaryFunction1DFloat, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DFloat_getName", _wrap_UnaryFunction1DFloat_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DFloat___call__", _wrap_UnaryFunction1DFloat___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DFloat_setIntegrationType", _wrap_UnaryFunction1DFloat_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DFloat_getIntegrationType", _wrap_UnaryFunction1DFloat_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DFloat", _wrap_disown_UnaryFunction1DFloat, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DFloat_swigregister", UnaryFunction1DFloat_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DDouble", _wrap_new_UnaryFunction1DDouble, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DDouble", _wrap_delete_UnaryFunction1DDouble, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DDouble_getName", _wrap_UnaryFunction1DDouble_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DDouble___call__", _wrap_UnaryFunction1DDouble___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DDouble_setIntegrationType", _wrap_UnaryFunction1DDouble_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DDouble_getIntegrationType", _wrap_UnaryFunction1DDouble_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DDouble", _wrap_disown_UnaryFunction1DDouble, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DDouble_swigregister", UnaryFunction1DDouble_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DVec2f", _wrap_new_UnaryFunction1DVec2f, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DVec2f", _wrap_delete_UnaryFunction1DVec2f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec2f_getName", _wrap_UnaryFunction1DVec2f_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec2f___call__", _wrap_UnaryFunction1DVec2f___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec2f_setIntegrationType", _wrap_UnaryFunction1DVec2f_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec2f_getIntegrationType", _wrap_UnaryFunction1DVec2f_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DVec2f", _wrap_disown_UnaryFunction1DVec2f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec2f_swigregister", UnaryFunction1DVec2f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DVec3f", _wrap_new_UnaryFunction1DVec3f, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DVec3f", _wrap_delete_UnaryFunction1DVec3f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec3f_getName", _wrap_UnaryFunction1DVec3f_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec3f___call__", _wrap_UnaryFunction1DVec3f___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec3f_setIntegrationType", _wrap_UnaryFunction1DVec3f_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec3f_getIntegrationType", _wrap_UnaryFunction1DVec3f_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryFunction1DVec3f", _wrap_disown_UnaryFunction1DVec3f, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVec3f_swigregister", UnaryFunction1DVec3f_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryFunction1DVectorViewShape", _wrap_new_UnaryFunction1DVectorViewShape, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryFunction1DVectorViewShape", _wrap_delete_UnaryFunction1DVectorViewShape, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVectorViewShape_getName", _wrap_UnaryFunction1DVectorViewShape_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVectorViewShape___call__", _wrap_UnaryFunction1DVectorViewShape___call__, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVectorViewShape_setIntegrationType", _wrap_UnaryFunction1DVectorViewShape_setIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVectorViewShape_getIntegrationType", _wrap_UnaryFunction1DVectorViewShape_getIntegrationType, METH_VARARGS, NULL},
+	 { (char *)"UnaryFunction1DVectorViewShape_swigregister", UnaryFunction1DVectorViewShape_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetXF1D", _wrap_new_GetXF1D, METH_VARARGS, NULL},
+	 { (char *)"GetXF1D_getName", _wrap_GetXF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetXF1D___call__", _wrap_GetXF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetXF1D", _wrap_delete_GetXF1D, METH_VARARGS, NULL},
+	 { (char *)"GetXF1D_swigregister", GetXF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetYF1D", _wrap_new_GetYF1D, METH_VARARGS, NULL},
+	 { (char *)"GetYF1D_getName", _wrap_GetYF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetYF1D___call__", _wrap_GetYF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetYF1D", _wrap_delete_GetYF1D, METH_VARARGS, NULL},
+	 { (char *)"GetYF1D_swigregister", GetYF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetZF1D", _wrap_new_GetZF1D, METH_VARARGS, NULL},
+	 { (char *)"GetZF1D_getName", _wrap_GetZF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetZF1D___call__", _wrap_GetZF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetZF1D", _wrap_delete_GetZF1D, METH_VARARGS, NULL},
+	 { (char *)"GetZF1D_swigregister", GetZF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedXF1D", _wrap_new_GetProjectedXF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF1D_getName", _wrap_GetProjectedXF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF1D___call__", _wrap_GetProjectedXF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedXF1D", _wrap_delete_GetProjectedXF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedXF1D_swigregister", GetProjectedXF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedYF1D", _wrap_new_GetProjectedYF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF1D_getName", _wrap_GetProjectedYF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF1D___call__", _wrap_GetProjectedYF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedYF1D", _wrap_delete_GetProjectedYF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedYF1D_swigregister", GetProjectedYF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetProjectedZF1D", _wrap_new_GetProjectedZF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF1D_getName", _wrap_GetProjectedZF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF1D___call__", _wrap_GetProjectedZF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetProjectedZF1D", _wrap_delete_GetProjectedZF1D, METH_VARARGS, NULL},
+	 { (char *)"GetProjectedZF1D_swigregister", GetProjectedZF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Orientation2DF1D", _wrap_new_Orientation2DF1D, METH_VARARGS, NULL},
+	 { (char *)"Orientation2DF1D_getName", _wrap_Orientation2DF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"Orientation2DF1D___call__", _wrap_Orientation2DF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_Orientation2DF1D", _wrap_delete_Orientation2DF1D, METH_VARARGS, NULL},
+	 { (char *)"Orientation2DF1D_swigregister", Orientation2DF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Orientation3DF1D", _wrap_new_Orientation3DF1D, METH_VARARGS, NULL},
+	 { (char *)"Orientation3DF1D_getName", _wrap_Orientation3DF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"Orientation3DF1D___call__", _wrap_Orientation3DF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_Orientation3DF1D", _wrap_delete_Orientation3DF1D, METH_VARARGS, NULL},
+	 { (char *)"Orientation3DF1D_swigregister", Orientation3DF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ZDiscontinuityF1D", _wrap_new_ZDiscontinuityF1D, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF1D_getName", _wrap_ZDiscontinuityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF1D___call__", _wrap_ZDiscontinuityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ZDiscontinuityF1D", _wrap_delete_ZDiscontinuityF1D, METH_VARARGS, NULL},
+	 { (char *)"ZDiscontinuityF1D_swigregister", ZDiscontinuityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_QuantitativeInvisibilityF1D", _wrap_new_QuantitativeInvisibilityF1D, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF1D_getName", _wrap_QuantitativeInvisibilityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF1D___call__", _wrap_QuantitativeInvisibilityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_QuantitativeInvisibilityF1D", _wrap_delete_QuantitativeInvisibilityF1D, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityF1D_swigregister", QuantitativeInvisibilityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_CurveNatureF1D", _wrap_new_CurveNatureF1D, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF1D_getName", _wrap_CurveNatureF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF1D___call__", _wrap_CurveNatureF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_CurveNatureF1D", _wrap_delete_CurveNatureF1D, METH_VARARGS, NULL},
+	 { (char *)"CurveNatureF1D_swigregister", CurveNatureF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"TimeStampF1D_getName", _wrap_TimeStampF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"TimeStampF1D___call__", _wrap_TimeStampF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_TimeStampF1D", _wrap_new_TimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"delete_TimeStampF1D", _wrap_delete_TimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"TimeStampF1D_swigregister", TimeStampF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"IncrementChainingTimeStampF1D_getName", _wrap_IncrementChainingTimeStampF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"IncrementChainingTimeStampF1D___call__", _wrap_IncrementChainingTimeStampF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_IncrementChainingTimeStampF1D", _wrap_new_IncrementChainingTimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"delete_IncrementChainingTimeStampF1D", _wrap_delete_IncrementChainingTimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"IncrementChainingTimeStampF1D_swigregister", IncrementChainingTimeStampF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ChainingTimeStampF1D_getName", _wrap_ChainingTimeStampF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ChainingTimeStampF1D___call__", _wrap_ChainingTimeStampF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ChainingTimeStampF1D", _wrap_new_ChainingTimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"delete_ChainingTimeStampF1D", _wrap_delete_ChainingTimeStampF1D, METH_VARARGS, NULL},
+	 { (char *)"ChainingTimeStampF1D_swigregister", ChainingTimeStampF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Curvature2DAngleF1D", _wrap_new_Curvature2DAngleF1D, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF1D_getName", _wrap_Curvature2DAngleF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF1D___call__", _wrap_Curvature2DAngleF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_Curvature2DAngleF1D", _wrap_delete_Curvature2DAngleF1D, METH_VARARGS, NULL},
+	 { (char *)"Curvature2DAngleF1D_swigregister", Curvature2DAngleF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Normal2DF1D", _wrap_new_Normal2DF1D, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF1D_getName", _wrap_Normal2DF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF1D___call__", _wrap_Normal2DF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_Normal2DF1D", _wrap_delete_Normal2DF1D, METH_VARARGS, NULL},
+	 { (char *)"Normal2DF1D_swigregister", Normal2DF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetShapeF1D", _wrap_new_GetShapeF1D, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF1D_getName", _wrap_GetShapeF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF1D___call__", _wrap_GetShapeF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetShapeF1D", _wrap_delete_GetShapeF1D, METH_VARARGS, NULL},
+	 { (char *)"GetShapeF1D_swigregister", GetShapeF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetOccludersF1D", _wrap_new_GetOccludersF1D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF1D_getName", _wrap_GetOccludersF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF1D___call__", _wrap_GetOccludersF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetOccludersF1D", _wrap_delete_GetOccludersF1D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludersF1D_swigregister", GetOccludersF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetOccludeeF1D", _wrap_new_GetOccludeeF1D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF1D_getName", _wrap_GetOccludeeF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF1D___call__", _wrap_GetOccludeeF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetOccludeeF1D", _wrap_delete_GetOccludeeF1D, METH_VARARGS, NULL},
+	 { (char *)"GetOccludeeF1D_swigregister", GetOccludeeF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Module_setAlwaysRefresh", _wrap_Module_setAlwaysRefresh, METH_VARARGS, NULL},
+	 { (char *)"Module_setCausal", _wrap_Module_setCausal, METH_VARARGS, NULL},
+	 { (char *)"Module_setDrawable", _wrap_Module_setDrawable, METH_VARARGS, NULL},
+	 { (char *)"Module_getAlwaysRefresh", _wrap_Module_getAlwaysRefresh, METH_VARARGS, NULL},
+	 { (char *)"Module_getCausal", _wrap_Module_getCausal, METH_VARARGS, NULL},
+	 { (char *)"Module_getDrawable", _wrap_Module_getDrawable, METH_VARARGS, NULL},
+	 { (char *)"new_Module", _wrap_new_Module, METH_VARARGS, NULL},
+	 { (char *)"delete_Module", _wrap_delete_Module, METH_VARARGS, NULL},
+	 { (char *)"Module_swigregister", Module_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_DensityF0D", _wrap_new_DensityF0D, METH_VARARGS, NULL},
+	 { (char *)"DensityF0D_getName", _wrap_DensityF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"DensityF0D___call__", _wrap_DensityF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_DensityF0D", _wrap_delete_DensityF0D, METH_VARARGS, NULL},
+	 { (char *)"DensityF0D_swigregister", DensityF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_LocalAverageDepthF0D", _wrap_new_LocalAverageDepthF0D, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF0D_getName", _wrap_LocalAverageDepthF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF0D___call__", _wrap_LocalAverageDepthF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_LocalAverageDepthF0D", _wrap_delete_LocalAverageDepthF0D, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF0D_swigregister", LocalAverageDepthF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ReadMapPixelF0D", _wrap_new_ReadMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadMapPixelF0D_getName", _wrap_ReadMapPixelF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"ReadMapPixelF0D___call__", _wrap_ReadMapPixelF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ReadMapPixelF0D", _wrap_delete_ReadMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadMapPixelF0D_swigregister", ReadMapPixelF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ReadSteerableViewMapPixelF0D", _wrap_new_ReadSteerableViewMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadSteerableViewMapPixelF0D_getName", _wrap_ReadSteerableViewMapPixelF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"ReadSteerableViewMapPixelF0D___call__", _wrap_ReadSteerableViewMapPixelF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ReadSteerableViewMapPixelF0D", _wrap_delete_ReadSteerableViewMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadSteerableViewMapPixelF0D_swigregister", ReadSteerableViewMapPixelF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ReadCompleteViewMapPixelF0D", _wrap_new_ReadCompleteViewMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadCompleteViewMapPixelF0D_getName", _wrap_ReadCompleteViewMapPixelF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"ReadCompleteViewMapPixelF0D___call__", _wrap_ReadCompleteViewMapPixelF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ReadCompleteViewMapPixelF0D", _wrap_delete_ReadCompleteViewMapPixelF0D, METH_VARARGS, NULL},
+	 { (char *)"ReadCompleteViewMapPixelF0D_swigregister", ReadCompleteViewMapPixelF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetViewMapGradientNormF0D", _wrap_new_GetViewMapGradientNormF0D, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF0D_getName", _wrap_GetViewMapGradientNormF0D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF0D___call__", _wrap_GetViewMapGradientNormF0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetViewMapGradientNormF0D", _wrap_delete_GetViewMapGradientNormF0D, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF0D_swigregister", GetViewMapGradientNormF0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_DensityF1D", _wrap_new_DensityF1D, METH_VARARGS, NULL},
+	 { (char *)"delete_DensityF1D", _wrap_delete_DensityF1D, METH_VARARGS, NULL},
+	 { (char *)"DensityF1D_getName", _wrap_DensityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"DensityF1D___call__", _wrap_DensityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"DensityF1D_swigregister", DensityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_LocalAverageDepthF1D", _wrap_new_LocalAverageDepthF1D, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF1D_getName", _wrap_LocalAverageDepthF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF1D___call__", _wrap_LocalAverageDepthF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_LocalAverageDepthF1D", _wrap_delete_LocalAverageDepthF1D, METH_VARARGS, NULL},
+	 { (char *)"LocalAverageDepthF1D_swigregister", LocalAverageDepthF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetCompleteViewMapDensityF1D", _wrap_new_GetCompleteViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"GetCompleteViewMapDensityF1D_getName", _wrap_GetCompleteViewMapDensityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetCompleteViewMapDensityF1D___call__", _wrap_GetCompleteViewMapDensityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetCompleteViewMapDensityF1D", _wrap_delete_GetCompleteViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"GetCompleteViewMapDensityF1D_swigregister", GetCompleteViewMapDensityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetDirectionalViewMapDensityF1D", _wrap_new_GetDirectionalViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"GetDirectionalViewMapDensityF1D_getName", _wrap_GetDirectionalViewMapDensityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetDirectionalViewMapDensityF1D___call__", _wrap_GetDirectionalViewMapDensityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetDirectionalViewMapDensityF1D", _wrap_delete_GetDirectionalViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"GetDirectionalViewMapDensityF1D_swigregister", GetDirectionalViewMapDensityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetSteerableViewMapDensityF1D", _wrap_new_GetSteerableViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"delete_GetSteerableViewMapDensityF1D", _wrap_delete_GetSteerableViewMapDensityF1D, METH_VARARGS, NULL},
+	 { (char *)"GetSteerableViewMapDensityF1D_getName", _wrap_GetSteerableViewMapDensityF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetSteerableViewMapDensityF1D___call__", _wrap_GetSteerableViewMapDensityF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"GetSteerableViewMapDensityF1D_swigregister", GetSteerableViewMapDensityF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GetViewMapGradientNormF1D", _wrap_new_GetViewMapGradientNormF1D, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF1D_getName", _wrap_GetViewMapGradientNormF1D_getName, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF1D___call__", _wrap_GetViewMapGradientNormF1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_GetViewMapGradientNormF1D", _wrap_delete_GetViewMapGradientNormF1D, METH_VARARGS, NULL},
+	 { (char *)"GetViewMapGradientNormF1D_swigregister", GetViewMapGradientNormF1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"GetTimeStampCF", _wrap_GetTimeStampCF, METH_VARARGS, NULL},
+	 { (char *)"GetCanvasWidthCF", _wrap_GetCanvasWidthCF, METH_VARARGS, NULL},
+	 { (char *)"GetCanvasHeightCF", _wrap_GetCanvasHeightCF, METH_VARARGS, NULL},
+	 { (char *)"LoadMapCF", _wrap_LoadMapCF, METH_VARARGS, NULL},
+	 { (char *)"ReadMapPixelCF", _wrap_ReadMapPixelCF, METH_VARARGS, NULL},
+	 { (char *)"ReadCompleteViewMapPixelCF", _wrap_ReadCompleteViewMapPixelCF, METH_VARARGS, NULL},
+	 { (char *)"ReadDirectionalViewMapPixelCF", _wrap_ReadDirectionalViewMapPixelCF, METH_VARARGS, NULL},
+	 { (char *)"GetSelectedFEdgeCF", _wrap_GetSelectedFEdgeCF, METH_VARARGS, NULL},
+	 { (char *)"new_AdjacencyIterator", _wrap_new_AdjacencyIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_AdjacencyIterator", _wrap_delete_AdjacencyIterator, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_isEnd", _wrap_AdjacencyIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_isBegin", _wrap_AdjacencyIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_isIncoming", _wrap_AdjacencyIterator_isIncoming, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getObject", _wrap_AdjacencyIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator___deref__", _wrap_AdjacencyIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_increment", _wrap_AdjacencyIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getExactTypeName", _wrap_AdjacencyIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getId", _wrap_AdjacencyIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getNature", _wrap_AdjacencyIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_userdata_set", _wrap_AdjacencyIterator_userdata_set, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_userdata_get", _wrap_AdjacencyIterator_userdata_get, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_A", _wrap_AdjacencyIterator_A, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_B", _wrap_AdjacencyIterator_B, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_fedgeA", _wrap_AdjacencyIterator_fedgeA, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_fedgeB", _wrap_AdjacencyIterator_fedgeB, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_viewShape", _wrap_AdjacencyIterator_viewShape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_aShape", _wrap_AdjacencyIterator_aShape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_isClosed", _wrap_AdjacencyIterator_isClosed, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getChainingTimeStamp", _wrap_AdjacencyIterator_getChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_bShape", _wrap_AdjacencyIterator_bShape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluders", _wrap_AdjacencyIterator_occluders, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_splittingId", _wrap_AdjacencyIterator_splittingId, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setA", _wrap_AdjacencyIterator_setA, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setB", _wrap_AdjacencyIterator_setB, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setNature", _wrap_AdjacencyIterator_setNature, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setFEdgeA", _wrap_AdjacencyIterator_setFEdgeA, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setFEdgeB", _wrap_AdjacencyIterator_setFEdgeB, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setShape", _wrap_AdjacencyIterator_setShape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setId", _wrap_AdjacencyIterator_setId, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_UpdateFEdges", _wrap_AdjacencyIterator_UpdateFEdges, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setaShape", _wrap_AdjacencyIterator_setaShape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setQI", _wrap_AdjacencyIterator_setQI, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setChainingTimeStamp", _wrap_AdjacencyIterator_setChainingTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_AddOccluder", _wrap_AdjacencyIterator_AddOccluder, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setSplittingId", _wrap_AdjacencyIterator_setSplittingId, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_intersect_2d_area", _wrap_AdjacencyIterator_intersect_2d_area, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_include_in_2d_area", _wrap_AdjacencyIterator_include_in_2d_area, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getLength2D", _wrap_AdjacencyIterator_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_qi", _wrap_AdjacencyIterator_qi, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluders_begin", _wrap_AdjacencyIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluders_end", _wrap_AdjacencyIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluders_size", _wrap_AdjacencyIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluders_empty", _wrap_AdjacencyIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occludee", _wrap_AdjacencyIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occluded_shape", _wrap_AdjacencyIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_occludee_empty", _wrap_AdjacencyIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_shape_id", _wrap_AdjacencyIterator_shape_id, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_shape", _wrap_AdjacencyIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_shape_importance", _wrap_AdjacencyIterator_shape_importance, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_verticesBegin", _wrap_AdjacencyIterator_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_verticesEnd", _wrap_AdjacencyIterator_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_pointsBegin", _wrap_AdjacencyIterator_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_pointsEnd", _wrap_AdjacencyIterator_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_getTimeStamp", _wrap_AdjacencyIterator_getTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_setTimeStamp", _wrap_AdjacencyIterator_setTimeStamp, METH_VARARGS, NULL},
+	 { (char *)"AdjacencyIterator_swigregister", AdjacencyIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ChainingIterator", _wrap_new_ChainingIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_getExactTypeName", _wrap_ChainingIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_init", _wrap_ChainingIterator_init, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_traverse", _wrap_ChainingIterator_traverse, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_getVertex", _wrap_ChainingIterator_getVertex, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_isIncrementing", _wrap_ChainingIterator_isIncrementing, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_increment", _wrap_ChainingIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_decrement", _wrap_ChainingIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"delete_ChainingIterator", _wrap_delete_ChainingIterator, METH_VARARGS, NULL},
+	 { (char *)"disown_ChainingIterator", _wrap_disown_ChainingIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainingIterator_swigregister", ChainingIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ChainSilhouetteIterator", _wrap_new_ChainSilhouetteIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainSilhouetteIterator_getExactTypeName", _wrap_ChainSilhouetteIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ChainSilhouetteIterator_traverse", _wrap_ChainSilhouetteIterator_traverse, METH_VARARGS, NULL},
+	 { (char *)"delete_ChainSilhouetteIterator", _wrap_delete_ChainSilhouetteIterator, METH_VARARGS, NULL},
+	 { (char *)"disown_ChainSilhouetteIterator", _wrap_disown_ChainSilhouetteIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainSilhouetteIterator_swigregister", ChainSilhouetteIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ChainPredicateIterator", _wrap_new_ChainPredicateIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_ChainPredicateIterator", _wrap_delete_ChainPredicateIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainPredicateIterator_getExactTypeName", _wrap_ChainPredicateIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"ChainPredicateIterator_traverse", _wrap_ChainPredicateIterator_traverse, METH_VARARGS, NULL},
+	 { (char *)"disown_ChainPredicateIterator", _wrap_disown_ChainPredicateIterator, METH_VARARGS, NULL},
+	 { (char *)"ChainPredicateIterator_swigregister", ChainPredicateIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryPredicate0D", _wrap_new_UnaryPredicate0D, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryPredicate0D", _wrap_delete_UnaryPredicate0D, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate0D_getName", _wrap_UnaryPredicate0D_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate0D___call__", _wrap_UnaryPredicate0D___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryPredicate0D", _wrap_disown_UnaryPredicate0D, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate0D_swigregister", UnaryPredicate0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_BinaryPredicate0D", _wrap_new_BinaryPredicate0D, METH_VARARGS, NULL},
+	 { (char *)"delete_BinaryPredicate0D", _wrap_delete_BinaryPredicate0D, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate0D_getName", _wrap_BinaryPredicate0D_getName, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate0D___call__", _wrap_BinaryPredicate0D___call__, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate0D_swigregister", BinaryPredicate0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_TrueUP0D", _wrap_new_TrueUP0D, METH_VARARGS, NULL},
+	 { (char *)"TrueUP0D_getName", _wrap_TrueUP0D_getName, METH_VARARGS, NULL},
+	 { (char *)"TrueUP0D___call__", _wrap_TrueUP0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_TrueUP0D", _wrap_delete_TrueUP0D, METH_VARARGS, NULL},
+	 { (char *)"TrueUP0D_swigregister", TrueUP0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FalseUP0D", _wrap_new_FalseUP0D, METH_VARARGS, NULL},
+	 { (char *)"FalseUP0D_getName", _wrap_FalseUP0D_getName, METH_VARARGS, NULL},
+	 { (char *)"FalseUP0D___call__", _wrap_FalseUP0D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_FalseUP0D", _wrap_delete_FalseUP0D, METH_VARARGS, NULL},
+	 { (char *)"FalseUP0D_swigregister", FalseUP0D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UnaryPredicate1D", _wrap_new_UnaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"delete_UnaryPredicate1D", _wrap_delete_UnaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate1D_getName", _wrap_UnaryPredicate1D_getName, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate1D___call__", _wrap_UnaryPredicate1D___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_UnaryPredicate1D", _wrap_disown_UnaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"UnaryPredicate1D_swigregister", UnaryPredicate1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_BinaryPredicate1D", _wrap_new_BinaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"delete_BinaryPredicate1D", _wrap_delete_BinaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate1D_getName", _wrap_BinaryPredicate1D_getName, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate1D___call__", _wrap_BinaryPredicate1D___call__, METH_VARARGS, NULL},
+	 { (char *)"disown_BinaryPredicate1D", _wrap_disown_BinaryPredicate1D, METH_VARARGS, NULL},
+	 { (char *)"BinaryPredicate1D_swigregister", BinaryPredicate1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_TrueUP1D", _wrap_new_TrueUP1D, METH_VARARGS, NULL},
+	 { (char *)"TrueUP1D_getName", _wrap_TrueUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"TrueUP1D___call__", _wrap_TrueUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_TrueUP1D", _wrap_delete_TrueUP1D, METH_VARARGS, NULL},
+	 { (char *)"TrueUP1D_swigregister", TrueUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FalseUP1D", _wrap_new_FalseUP1D, METH_VARARGS, NULL},
+	 { (char *)"FalseUP1D_getName", _wrap_FalseUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"FalseUP1D___call__", _wrap_FalseUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_FalseUP1D", _wrap_delete_FalseUP1D, METH_VARARGS, NULL},
+	 { (char *)"FalseUP1D_swigregister", FalseUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_QuantitativeInvisibilityUP1D", _wrap_new_QuantitativeInvisibilityUP1D, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityUP1D_getName", _wrap_QuantitativeInvisibilityUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityUP1D___call__", _wrap_QuantitativeInvisibilityUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_QuantitativeInvisibilityUP1D", _wrap_delete_QuantitativeInvisibilityUP1D, METH_VARARGS, NULL},
+	 { (char *)"QuantitativeInvisibilityUP1D_swigregister", QuantitativeInvisibilityUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ContourUP1D_getName", _wrap_ContourUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ContourUP1D___call__", _wrap_ContourUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ContourUP1D", _wrap_new_ContourUP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_ContourUP1D", _wrap_delete_ContourUP1D, METH_VARARGS, NULL},
+	 { (char *)"ContourUP1D_swigregister", ContourUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ExternalContourUP1D_getName", _wrap_ExternalContourUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ExternalContourUP1D___call__", _wrap_ExternalContourUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ExternalContourUP1D", _wrap_new_ExternalContourUP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_ExternalContourUP1D", _wrap_delete_ExternalContourUP1D, METH_VARARGS, NULL},
+	 { (char *)"ExternalContourUP1D_swigregister", ExternalContourUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_EqualToTimeStampUP1D", _wrap_new_EqualToTimeStampUP1D, METH_VARARGS, NULL},
+	 { (char *)"EqualToTimeStampUP1D_getName", _wrap_EqualToTimeStampUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"EqualToTimeStampUP1D___call__", _wrap_EqualToTimeStampUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_EqualToTimeStampUP1D", _wrap_delete_EqualToTimeStampUP1D, METH_VARARGS, NULL},
+	 { (char *)"EqualToTimeStampUP1D_swigregister", EqualToTimeStampUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_EqualToChainingTimeStampUP1D", _wrap_new_EqualToChainingTimeStampUP1D, METH_VARARGS, NULL},
+	 { (char *)"EqualToChainingTimeStampUP1D_getName", _wrap_EqualToChainingTimeStampUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"EqualToChainingTimeStampUP1D___call__", _wrap_EqualToChainingTimeStampUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_EqualToChainingTimeStampUP1D", _wrap_delete_EqualToChainingTimeStampUP1D, METH_VARARGS, NULL},
+	 { (char *)"EqualToChainingTimeStampUP1D_swigregister", EqualToChainingTimeStampUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ShapeUP1D", _wrap_new_ShapeUP1D, METH_VARARGS, NULL},
+	 { (char *)"ShapeUP1D_getName", _wrap_ShapeUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ShapeUP1D___call__", _wrap_ShapeUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ShapeUP1D", _wrap_delete_ShapeUP1D, METH_VARARGS, NULL},
+	 { (char *)"ShapeUP1D_swigregister", ShapeUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"TrueBP1D_getName", _wrap_TrueBP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"TrueBP1D___call__", _wrap_TrueBP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_TrueBP1D", _wrap_new_TrueBP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_TrueBP1D", _wrap_delete_TrueBP1D, METH_VARARGS, NULL},
+	 { (char *)"TrueBP1D_swigregister", TrueBP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"FalseBP1D_getName", _wrap_FalseBP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"FalseBP1D___call__", _wrap_FalseBP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_FalseBP1D", _wrap_new_FalseBP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_FalseBP1D", _wrap_delete_FalseBP1D, METH_VARARGS, NULL},
+	 { (char *)"FalseBP1D_swigregister", FalseBP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Length2DBP1D_getName", _wrap_Length2DBP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"Length2DBP1D___call__", _wrap_Length2DBP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_Length2DBP1D", _wrap_new_Length2DBP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_Length2DBP1D", _wrap_delete_Length2DBP1D, METH_VARARGS, NULL},
+	 { (char *)"Length2DBP1D_swigregister", Length2DBP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"SameShapeIdBP1D_getName", _wrap_SameShapeIdBP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"SameShapeIdBP1D___call__", _wrap_SameShapeIdBP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"new_SameShapeIdBP1D", _wrap_new_SameShapeIdBP1D, METH_VARARGS, NULL},
+	 { (char *)"delete_SameShapeIdBP1D", _wrap_delete_SameShapeIdBP1D, METH_VARARGS, NULL},
+	 { (char *)"SameShapeIdBP1D_swigregister", SameShapeIdBP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ViewMapGradientNormBP1D", _wrap_new_ViewMapGradientNormBP1D, METH_VARARGS, NULL},
+	 { (char *)"ViewMapGradientNormBP1D_getName", _wrap_ViewMapGradientNormBP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"ViewMapGradientNormBP1D___call__", _wrap_ViewMapGradientNormBP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_ViewMapGradientNormBP1D", _wrap_delete_ViewMapGradientNormBP1D, METH_VARARGS, NULL},
+	 { (char *)"ViewMapGradientNormBP1D_swigregister", ViewMapGradientNormBP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_DensityLowerThanUP1D", _wrap_new_DensityLowerThanUP1D, METH_VARARGS, NULL},
+	 { (char *)"DensityLowerThanUP1D_getName", _wrap_DensityLowerThanUP1D_getName, METH_VARARGS, NULL},
+	 { (char *)"DensityLowerThanUP1D___call__", _wrap_DensityLowerThanUP1D___call__, METH_VARARGS, NULL},
+	 { (char *)"delete_DensityLowerThanUP1D", _wrap_delete_DensityLowerThanUP1D, METH_VARARGS, NULL},
+	 { (char *)"DensityLowerThanUP1D_swigregister", DensityLowerThanUP1D_swigregister, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__CurvilinearLength_set", _wrap_CurvePointIterator__CurvilinearLength_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__CurvilinearLength_get", _wrap_CurvePointIterator__CurvilinearLength_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__step_set", _wrap_CurvePointIterator__step_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__step_get", _wrap_CurvePointIterator__step_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___A_set", _wrap_CurvePointIterator___A_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___A_get", _wrap_CurvePointIterator___A_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___B_set", _wrap_CurvePointIterator___B_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___B_get", _wrap_CurvePointIterator___B_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__begin_set", _wrap_CurvePointIterator__begin_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__begin_get", _wrap_CurvePointIterator__begin_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__end_set", _wrap_CurvePointIterator__end_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__end_get", _wrap_CurvePointIterator__end_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__n_set", _wrap_CurvePointIterator__n_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__n_get", _wrap_CurvePointIterator__n_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__currentn_set", _wrap_CurvePointIterator__currentn_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__currentn_get", _wrap_CurvePointIterator__currentn_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__t_set", _wrap_CurvePointIterator__t_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__t_get", _wrap_CurvePointIterator__t_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__Point_set", _wrap_CurvePointIterator__Point_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__Point_get", _wrap_CurvePointIterator__Point_get, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__CurveLength_set", _wrap_CurvePointIterator__CurveLength_set, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator__CurveLength_get", _wrap_CurvePointIterator__CurveLength_get, METH_VARARGS, NULL},
+	 { (char *)"new_CurvePointIterator", _wrap_new_CurvePointIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_CurvePointIterator", _wrap_delete_CurvePointIterator, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_copy", _wrap_CurvePointIterator_copy, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_CastToInterface0DIterator", _wrap_CurvePointIterator_CastToInterface0DIterator, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getExactTypeName", _wrap_CurvePointIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___eq__", _wrap_CurvePointIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getObject", _wrap_CurvePointIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator___deref__", _wrap_CurvePointIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_isBegin", _wrap_CurvePointIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_isEnd", _wrap_CurvePointIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getX", _wrap_CurvePointIterator_getX, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getY", _wrap_CurvePointIterator_getY, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getZ", _wrap_CurvePointIterator_getZ, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getPoint3D", _wrap_CurvePointIterator_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getProjectedX", _wrap_CurvePointIterator_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getProjectedY", _wrap_CurvePointIterator_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getProjectedZ", _wrap_CurvePointIterator_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getPoint2D", _wrap_CurvePointIterator_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getFEdge", _wrap_CurvePointIterator_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getId", _wrap_CurvePointIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_getNature", _wrap_CurvePointIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_castToSVertex", _wrap_CurvePointIterator_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_castToViewVertex", _wrap_CurvePointIterator_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_castToNonTVertex", _wrap_CurvePointIterator_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_castToTVertex", _wrap_CurvePointIterator_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_A", _wrap_CurvePointIterator_A, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_B", _wrap_CurvePointIterator_B, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_t2d", _wrap_CurvePointIterator_t2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_setA", _wrap_CurvePointIterator_setA, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_setB", _wrap_CurvePointIterator_setB, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_setT2d", _wrap_CurvePointIterator_setT2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_fedge", _wrap_CurvePointIterator_fedge, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_point2d", _wrap_CurvePointIterator_point2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_point3d", _wrap_CurvePointIterator_point3d, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_normal", _wrap_CurvePointIterator_normal, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_shape", _wrap_CurvePointIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occluders_begin", _wrap_CurvePointIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occluders_end", _wrap_CurvePointIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occluders_empty", _wrap_CurvePointIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occluders_size", _wrap_CurvePointIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occludee", _wrap_CurvePointIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occluded_shape", _wrap_CurvePointIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_occludee_empty", _wrap_CurvePointIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_z_discontinuity", _wrap_CurvePointIterator_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_curvatureFredo", _wrap_CurvePointIterator_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_directionFredo", _wrap_CurvePointIterator_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"CurvePointIterator_swigregister", CurvePointIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getExactTypeName", _wrap_CurvePoint_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getX", _wrap_CurvePoint_getX, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getY", _wrap_CurvePoint_getY, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getZ", _wrap_CurvePoint_getZ, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getPoint3D", _wrap_CurvePoint_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getProjectedX", _wrap_CurvePoint_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getProjectedY", _wrap_CurvePoint_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getProjectedZ", _wrap_CurvePoint_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getPoint2D", _wrap_CurvePoint_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getFEdge", _wrap_CurvePoint_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getId", _wrap_CurvePoint_getId, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_getNature", _wrap_CurvePoint_getNature, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_castToSVertex", _wrap_CurvePoint_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_castToViewVertex", _wrap_CurvePoint_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_castToNonTVertex", _wrap_CurvePoint_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_castToTVertex", _wrap_CurvePoint_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"new_CurvePoint", _wrap_new_CurvePoint, METH_VARARGS, NULL},
+	 { (char *)"delete_CurvePoint", _wrap_delete_CurvePoint, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint___eq__", _wrap_CurvePoint___eq__, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_A", _wrap_CurvePoint_A, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_B", _wrap_CurvePoint_B, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_t2d", _wrap_CurvePoint_t2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_setA", _wrap_CurvePoint_setA, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_setB", _wrap_CurvePoint_setB, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_setT2d", _wrap_CurvePoint_setT2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_fedge", _wrap_CurvePoint_fedge, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_point2d", _wrap_CurvePoint_point2d, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_point3d", _wrap_CurvePoint_point3d, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_normal", _wrap_CurvePoint_normal, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_shape", _wrap_CurvePoint_shape, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occluders_begin", _wrap_CurvePoint_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occluders_end", _wrap_CurvePoint_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occluders_empty", _wrap_CurvePoint_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occluders_size", _wrap_CurvePoint_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occludee", _wrap_CurvePoint_occludee, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occluded_shape", _wrap_CurvePoint_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_occludee_empty", _wrap_CurvePoint_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_z_discontinuity", _wrap_CurvePoint_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_curvatureFredo", _wrap_CurvePoint_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_directionFredo", _wrap_CurvePoint_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"CurvePoint_swigregister", CurvePoint_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Curve", _wrap_new_Curve, METH_VARARGS, NULL},
+	 { (char *)"delete_Curve", _wrap_delete_Curve, METH_VARARGS, NULL},
+	 { (char *)"Curve_computeCurvatureAndOrientation", _wrap_Curve_computeCurvatureAndOrientation, METH_VARARGS, NULL},
+	 { (char *)"Curve_push_vertex_back", _wrap_Curve_push_vertex_back, METH_VARARGS, NULL},
+	 { (char *)"Curve_push_vertex_front", _wrap_Curve_push_vertex_front, METH_VARARGS, NULL},
+	 { (char *)"Curve_empty", _wrap_Curve_empty, METH_VARARGS, NULL},
+	 { (char *)"Curve_getLength2D", _wrap_Curve_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"Curve_getId", _wrap_Curve_getId, METH_VARARGS, NULL},
+	 { (char *)"Curve_nSegments", _wrap_Curve_nSegments, METH_VARARGS, NULL},
+	 { (char *)"Curve_setId", _wrap_Curve_setId, METH_VARARGS, NULL},
+	 { (char *)"Curve_curvePointsBegin", _wrap_Curve_curvePointsBegin, METH_VARARGS, NULL},
+	 { (char *)"Curve_curvePointsEnd", _wrap_Curve_curvePointsEnd, METH_VARARGS, NULL},
+	 { (char *)"Curve_curveVerticesBegin", _wrap_Curve_curveVerticesBegin, METH_VARARGS, NULL},
+	 { (char *)"Curve_curveVerticesEnd", _wrap_Curve_curveVerticesEnd, METH_VARARGS, NULL},
+	 { (char *)"Curve_verticesBegin", _wrap_Curve_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"Curve_verticesEnd", _wrap_Curve_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"Curve_pointsBegin", _wrap_Curve_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"Curve_pointsEnd", _wrap_Curve_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"Curve_swigregister", Curve_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_StrokeVertexIterator", _wrap_new_StrokeVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"delete_StrokeVertexIterator", _wrap_delete_StrokeVertexIterator, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_castToInterface0DIterator", _wrap_StrokeVertexIterator_castToInterface0DIterator, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getExactTypeName", _wrap_StrokeVertexIterator_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getObject", _wrap_StrokeVertexIterator_getObject, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator___deref__", _wrap_StrokeVertexIterator___deref__, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_increment", _wrap_StrokeVertexIterator_increment, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_decrement", _wrap_StrokeVertexIterator_decrement, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_isBegin", _wrap_StrokeVertexIterator_isBegin, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_isEnd", _wrap_StrokeVertexIterator_isEnd, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator___eq__", _wrap_StrokeVertexIterator___eq__, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_t", _wrap_StrokeVertexIterator_t, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_u", _wrap_StrokeVertexIterator_u, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_copy", _wrap_StrokeVertexIterator_copy, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getIt", _wrap_StrokeVertexIterator_getIt, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_x", _wrap_StrokeVertexIterator_x, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_y", _wrap_StrokeVertexIterator_y, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getPoint", _wrap_StrokeVertexIterator_getPoint, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_attribute", _wrap_StrokeVertexIterator_attribute, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_curvilinearAbscissa", _wrap_StrokeVertexIterator_curvilinearAbscissa, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_strokeLength", _wrap_StrokeVertexIterator_strokeLength, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setX", _wrap_StrokeVertexIterator_setX, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setY", _wrap_StrokeVertexIterator_setY, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setPoint", _wrap_StrokeVertexIterator_setPoint, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setAttribute", _wrap_StrokeVertexIterator_setAttribute, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setCurvilinearAbscissa", _wrap_StrokeVertexIterator_setCurvilinearAbscissa, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setStrokeLength", _wrap_StrokeVertexIterator_setStrokeLength, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getX", _wrap_StrokeVertexIterator_getX, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getY", _wrap_StrokeVertexIterator_getY, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getZ", _wrap_StrokeVertexIterator_getZ, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getPoint3D", _wrap_StrokeVertexIterator_getPoint3D, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getProjectedX", _wrap_StrokeVertexIterator_getProjectedX, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getProjectedY", _wrap_StrokeVertexIterator_getProjectedY, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getProjectedZ", _wrap_StrokeVertexIterator_getProjectedZ, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getPoint2D", _wrap_StrokeVertexIterator_getPoint2D, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getFEdge", _wrap_StrokeVertexIterator_getFEdge, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getId", _wrap_StrokeVertexIterator_getId, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_getNature", _wrap_StrokeVertexIterator_getNature, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_castToSVertex", _wrap_StrokeVertexIterator_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_castToViewVertex", _wrap_StrokeVertexIterator_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_castToNonTVertex", _wrap_StrokeVertexIterator_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_castToTVertex", _wrap_StrokeVertexIterator_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_A", _wrap_StrokeVertexIterator_A, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_B", _wrap_StrokeVertexIterator_B, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_t2d", _wrap_StrokeVertexIterator_t2d, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setA", _wrap_StrokeVertexIterator_setA, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setB", _wrap_StrokeVertexIterator_setB, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_setT2d", _wrap_StrokeVertexIterator_setT2d, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_fedge", _wrap_StrokeVertexIterator_fedge, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_point2d", _wrap_StrokeVertexIterator_point2d, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_point3d", _wrap_StrokeVertexIterator_point3d, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_normal", _wrap_StrokeVertexIterator_normal, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_shape", _wrap_StrokeVertexIterator_shape, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occluders_begin", _wrap_StrokeVertexIterator_occluders_begin, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occluders_end", _wrap_StrokeVertexIterator_occluders_end, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occluders_empty", _wrap_StrokeVertexIterator_occluders_empty, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occluders_size", _wrap_StrokeVertexIterator_occluders_size, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occludee", _wrap_StrokeVertexIterator_occludee, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occluded_shape", _wrap_StrokeVertexIterator_occluded_shape, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_occludee_empty", _wrap_StrokeVertexIterator_occludee_empty, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_z_discontinuity", _wrap_StrokeVertexIterator_z_discontinuity, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_curvatureFredo", _wrap_StrokeVertexIterator_curvatureFredo, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_directionFredo", _wrap_StrokeVertexIterator_directionFredo, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertexIterator_swigregister", StrokeVertexIterator_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_StrokeAttribute", _wrap_new_StrokeAttribute, METH_VARARGS, NULL},
+	 { (char *)"delete_StrokeAttribute", _wrap_delete_StrokeAttribute, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getColor", _wrap_StrokeAttribute_getColor, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getColorR", _wrap_StrokeAttribute_getColorR, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getColorG", _wrap_StrokeAttribute_getColorG, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getColorB", _wrap_StrokeAttribute_getColorB, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getColorRGB", _wrap_StrokeAttribute_getColorRGB, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getAlpha", _wrap_StrokeAttribute_getAlpha, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getThickness", _wrap_StrokeAttribute_getThickness, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getThicknessR", _wrap_StrokeAttribute_getThicknessR, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getThicknessL", _wrap_StrokeAttribute_getThicknessL, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getThicknessRL", _wrap_StrokeAttribute_getThicknessRL, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_isVisible", _wrap_StrokeAttribute_isVisible, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getAttributeReal", _wrap_StrokeAttribute_getAttributeReal, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getAttributeVec2f", _wrap_StrokeAttribute_getAttributeVec2f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_getAttributeVec3f", _wrap_StrokeAttribute_getAttributeVec3f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_isAttributeAvailableReal", _wrap_StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_isAttributeAvailableVec2f", _wrap_StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_isAttributeAvailableVec3f", _wrap_StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setColor", _wrap_StrokeAttribute_setColor, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setAlpha", _wrap_StrokeAttribute_setAlpha, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setThickness", _wrap_StrokeAttribute_setThickness, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setVisible", _wrap_StrokeAttribute_setVisible, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setAttributeReal", _wrap_StrokeAttribute_setAttributeReal, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setAttributeVec2f", _wrap_StrokeAttribute_setAttributeVec2f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_setAttributeVec3f", _wrap_StrokeAttribute_setAttributeVec3f, METH_VARARGS, NULL},
+	 { (char *)"StrokeAttribute_swigregister", StrokeAttribute_swigregister, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_getExactTypeName", _wrap_StrokeVertex_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"new_StrokeVertex", _wrap_new_StrokeVertex, METH_VARARGS, NULL},
+	 { (char *)"delete_StrokeVertex", _wrap_delete_StrokeVertex, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_x", _wrap_StrokeVertex_x, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_y", _wrap_StrokeVertex_y, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_getPoint", _wrap_StrokeVertex_getPoint, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_attribute", _wrap_StrokeVertex_attribute, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_curvilinearAbscissa", _wrap_StrokeVertex_curvilinearAbscissa, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_strokeLength", _wrap_StrokeVertex_strokeLength, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_u", _wrap_StrokeVertex_u, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setX", _wrap_StrokeVertex_setX, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setY", _wrap_StrokeVertex_setY, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setPoint", _wrap_StrokeVertex_setPoint, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setAttribute", _wrap_StrokeVertex_setAttribute, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setCurvilinearAbscissa", _wrap_StrokeVertex_setCurvilinearAbscissa, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_setStrokeLength", _wrap_StrokeVertex_setStrokeLength, METH_VARARGS, NULL},
+	 { (char *)"StrokeVertex_swigregister", StrokeVertex_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getExactTypeName", _wrap_Stroke_getExactTypeName, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getId", _wrap_Stroke_getId, METH_VARARGS, NULL},
+	 { (char *)"new_Stroke", _wrap_new_Stroke, METH_VARARGS, NULL},
+	 { (char *)"delete_Stroke", _wrap_delete_Stroke, METH_VARARGS, NULL},
+	 { (char *)"Stroke_ComputeSampling", _wrap_Stroke_ComputeSampling, METH_VARARGS, NULL},
+	 { (char *)"Stroke_Resample", _wrap_Stroke_Resample, METH_VARARGS, NULL},
+	 { (char *)"Stroke_RemoveVertex", _wrap_Stroke_RemoveVertex, METH_VARARGS, NULL},
+	 { (char *)"Stroke_InsertVertex", _wrap_Stroke_InsertVertex, METH_VARARGS, NULL},
+	 { (char *)"Stroke_Render", _wrap_Stroke_Render, METH_VARARGS, NULL},
+	 { (char *)"Stroke_RenderBasic", _wrap_Stroke_RenderBasic, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getLength2D", _wrap_Stroke_getLength2D, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getMediumType", _wrap_Stroke_getMediumType, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getTextureId", _wrap_Stroke_getTextureId, METH_VARARGS, NULL},
+	 { (char *)"Stroke_hasTips", _wrap_Stroke_hasTips, METH_VARARGS, NULL},
+	 { (char *)"Stroke_vertices_size", _wrap_Stroke_vertices_size, METH_VARARGS, NULL},
+	 { (char *)"Stroke_viewedges_begin", _wrap_Stroke_viewedges_begin, METH_VARARGS, NULL},
+	 { (char *)"Stroke_viewedges_end", _wrap_Stroke_viewedges_end, METH_VARARGS, NULL},
+	 { (char *)"Stroke_viewedges_size", _wrap_Stroke_viewedges_size, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getBeginningOrientation", _wrap_Stroke_getBeginningOrientation, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getBeginningOrientationX", _wrap_Stroke_getBeginningOrientationX, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getBeginningOrientationY", _wrap_Stroke_getBeginningOrientationY, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getEndingOrientation", _wrap_Stroke_getEndingOrientation, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getEndingOrientationX", _wrap_Stroke_getEndingOrientationX, METH_VARARGS, NULL},
+	 { (char *)"Stroke_getEndingOrientationY", _wrap_Stroke_getEndingOrientationY, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setId", _wrap_Stroke_setId, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setLength", _wrap_Stroke_setLength, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setMediumType", _wrap_Stroke_setMediumType, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setTextureId", _wrap_Stroke_setTextureId, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setTips", _wrap_Stroke_setTips, METH_VARARGS, NULL},
+	 { (char *)"Stroke_push_back", _wrap_Stroke_push_back, METH_VARARGS, NULL},
+	 { (char *)"Stroke_push_front", _wrap_Stroke_push_front, METH_VARARGS, NULL},
+	 { (char *)"Stroke_AddViewEdge", _wrap_Stroke_AddViewEdge, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setBeginningOrientation", _wrap_Stroke_setBeginningOrientation, METH_VARARGS, NULL},
+	 { (char *)"Stroke_setEndingOrientation", _wrap_Stroke_setEndingOrientation, METH_VARARGS, NULL},
+	 { (char *)"Stroke_strokeVerticesBegin", _wrap_Stroke_strokeVerticesBegin, METH_VARARGS, NULL},
+	 { (char *)"Stroke_strokeVerticesEnd", _wrap_Stroke_strokeVerticesEnd, METH_VARARGS, NULL},
+	 { (char *)"Stroke_strokeVerticesSize", _wrap_Stroke_strokeVerticesSize, METH_VARARGS, NULL},
+	 { (char *)"Stroke_verticesBegin", _wrap_Stroke_verticesBegin, METH_VARARGS, NULL},
+	 { (char *)"Stroke_verticesEnd", _wrap_Stroke_verticesEnd, METH_VARARGS, NULL},
+	 { (char *)"Stroke_pointsBegin", _wrap_Stroke_pointsBegin, METH_VARARGS, NULL},
+	 { (char *)"Stroke_pointsEnd", _wrap_Stroke_pointsEnd, METH_VARARGS, NULL},
+	 { (char *)"Stroke_swigregister", Stroke_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_iterator", _wrap_ShadersContainer_iterator, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___nonzero__", _wrap_ShadersContainer___nonzero__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___len__", _wrap_ShadersContainer___len__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_pop", _wrap_ShadersContainer_pop, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___getslice__", _wrap_ShadersContainer___getslice__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___setslice__", _wrap_ShadersContainer___setslice__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___delslice__", _wrap_ShadersContainer___delslice__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___delitem__", _wrap_ShadersContainer___delitem__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___getitem__", _wrap_ShadersContainer___getitem__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer___setitem__", _wrap_ShadersContainer___setitem__, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_append", _wrap_ShadersContainer_append, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_empty", _wrap_ShadersContainer_empty, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_size", _wrap_ShadersContainer_size, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_clear", _wrap_ShadersContainer_clear, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_swap", _wrap_ShadersContainer_swap, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_get_allocator", _wrap_ShadersContainer_get_allocator, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_begin", _wrap_ShadersContainer_begin, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_end", _wrap_ShadersContainer_end, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_rbegin", _wrap_ShadersContainer_rbegin, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_rend", _wrap_ShadersContainer_rend, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_pop_back", _wrap_ShadersContainer_pop_back, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_erase", _wrap_ShadersContainer_erase, METH_VARARGS, NULL},
+	 { (char *)"new_ShadersContainer", _wrap_new_ShadersContainer, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_push_back", _wrap_ShadersContainer_push_back, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_front", _wrap_ShadersContainer_front, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_back", _wrap_ShadersContainer_back, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_assign", _wrap_ShadersContainer_assign, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_resize", _wrap_ShadersContainer_resize, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_insert", _wrap_ShadersContainer_insert, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_reserve", _wrap_ShadersContainer_reserve, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_capacity", _wrap_ShadersContainer_capacity, METH_VARARGS, NULL},
+	 { (char *)"delete_ShadersContainer", _wrap_delete_ShadersContainer, METH_VARARGS, NULL},
+	 { (char *)"ShadersContainer_swigregister", ShadersContainer_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_StrokeShader", _wrap_new_StrokeShader, METH_VARARGS, NULL},
+	 { (char *)"delete_StrokeShader", _wrap_delete_StrokeShader, METH_VARARGS, NULL},
+	 { (char *)"StrokeShader_getName", _wrap_StrokeShader_getName, METH_VARARGS, NULL},
+	 { (char *)"StrokeShader_shade", _wrap_StrokeShader_shade, METH_VARARGS, NULL},
+	 { (char *)"disown_StrokeShader", _wrap_disown_StrokeShader, METH_VARARGS, NULL},
+	 { (char *)"StrokeShader_swigregister", StrokeShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ConstantThicknessShader", _wrap_new_ConstantThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"delete_ConstantThicknessShader", _wrap_delete_ConstantThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"ConstantThicknessShader_getName", _wrap_ConstantThicknessShader_getName, METH_VARARGS, NULL},
+	 { (char *)"ConstantThicknessShader_shade", _wrap_ConstantThicknessShader_shade, METH_VARARGS, NULL},
+	 { (char *)"ConstantThicknessShader_swigregister", ConstantThicknessShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ConstantExternThicknessShader", _wrap_new_ConstantExternThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"delete_ConstantExternThicknessShader", _wrap_delete_ConstantExternThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"ConstantExternThicknessShader_getName", _wrap_ConstantExternThicknessShader_getName, METH_VARARGS, NULL},
+	 { (char *)"ConstantExternThicknessShader_shade", _wrap_ConstantExternThicknessShader_shade, METH_VARARGS, NULL},
+	 { (char *)"ConstantExternThicknessShader_swigregister", ConstantExternThicknessShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_IncreasingThicknessShader", _wrap_new_IncreasingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"delete_IncreasingThicknessShader", _wrap_delete_IncreasingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"IncreasingThicknessShader_shade", _wrap_IncreasingThicknessShader_shade, METH_VARARGS, NULL},
+	 { (char *)"IncreasingThicknessShader_swigregister", IncreasingThicknessShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ConstrainedIncreasingThicknessShader", _wrap_new_ConstrainedIncreasingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"delete_ConstrainedIncreasingThicknessShader", _wrap_delete_ConstrainedIncreasingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"ConstrainedIncreasingThicknessShader_shade", _wrap_ConstrainedIncreasingThicknessShader_shade, METH_VARARGS, NULL},
+	 { (char *)"ConstrainedIncreasingThicknessShader_swigregister", ConstrainedIncreasingThicknessShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_LengthDependingThicknessShader", _wrap_new_LengthDependingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"delete_LengthDependingThicknessShader", _wrap_delete_LengthDependingThicknessShader, METH_VARARGS, NULL},
+	 { (char *)"LengthDependingThicknessShader_shade", _wrap_LengthDependingThicknessShader_shade, METH_VARARGS, NULL},
+	 { (char *)"LengthDependingThicknessShader_swigregister", LengthDependingThicknessShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ThicknessVariationPatternShader", _wrap_new_ThicknessVariationPatternShader, METH_VARARGS, NULL},
+	 { (char *)"delete_ThicknessVariationPatternShader", _wrap_delete_ThicknessVariationPatternShader, METH_VARARGS, NULL},
+	 { (char *)"ThicknessVariationPatternShader_shade", _wrap_ThicknessVariationPatternShader_shade, METH_VARARGS, NULL},
+	 { (char *)"ThicknessVariationPatternShader_swigregister", ThicknessVariationPatternShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ThicknessNoiseShader", _wrap_new_ThicknessNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"ThicknessNoiseShader_shade", _wrap_ThicknessNoiseShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_ThicknessNoiseShader", _wrap_delete_ThicknessNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"ThicknessNoiseShader_swigregister", ThicknessNoiseShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ConstantColorShader", _wrap_new_ConstantColorShader, METH_VARARGS, NULL},
+	 { (char *)"ConstantColorShader_getName", _wrap_ConstantColorShader_getName, METH_VARARGS, NULL},
+	 { (char *)"ConstantColorShader_shade", _wrap_ConstantColorShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_ConstantColorShader", _wrap_delete_ConstantColorShader, METH_VARARGS, NULL},
+	 { (char *)"ConstantColorShader_swigregister", ConstantColorShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_IncreasingColorShader", _wrap_new_IncreasingColorShader, METH_VARARGS, NULL},
+	 { (char *)"IncreasingColorShader_shade", _wrap_IncreasingColorShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_IncreasingColorShader", _wrap_delete_IncreasingColorShader, METH_VARARGS, NULL},
+	 { (char *)"IncreasingColorShader_swigregister", IncreasingColorShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ColorVariationPatternShader", _wrap_new_ColorVariationPatternShader, METH_VARARGS, NULL},
+	 { (char *)"delete_ColorVariationPatternShader", _wrap_delete_ColorVariationPatternShader, METH_VARARGS, NULL},
+	 { (char *)"ColorVariationPatternShader_shade", _wrap_ColorVariationPatternShader_shade, METH_VARARGS, NULL},
+	 { (char *)"ColorVariationPatternShader_swigregister", ColorVariationPatternShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_MaterialColorShader", _wrap_new_MaterialColorShader, METH_VARARGS, NULL},
+	 { (char *)"MaterialColorShader_shade", _wrap_MaterialColorShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_MaterialColorShader", _wrap_delete_MaterialColorShader, METH_VARARGS, NULL},
+	 { (char *)"MaterialColorShader_swigregister", MaterialColorShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_CalligraphicColorShader", _wrap_new_CalligraphicColorShader, METH_VARARGS, NULL},
+	 { (char *)"CalligraphicColorShader_shade", _wrap_CalligraphicColorShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_CalligraphicColorShader", _wrap_delete_CalligraphicColorShader, METH_VARARGS, NULL},
+	 { (char *)"CalligraphicColorShader_swigregister", CalligraphicColorShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ColorNoiseShader", _wrap_new_ColorNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"ColorNoiseShader_shade", _wrap_ColorNoiseShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_ColorNoiseShader", _wrap_delete_ColorNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"ColorNoiseShader_swigregister", ColorNoiseShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_TextureAssignerShader", _wrap_new_TextureAssignerShader, METH_VARARGS, NULL},
+	 { (char *)"TextureAssignerShader_shade", _wrap_TextureAssignerShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_TextureAssignerShader", _wrap_delete_TextureAssignerShader, METH_VARARGS, NULL},
+	 { (char *)"TextureAssignerShader_swigregister", TextureAssignerShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_StrokeTextureShader", _wrap_new_StrokeTextureShader, METH_VARARGS, NULL},
+	 { (char *)"StrokeTextureShader_shade", _wrap_StrokeTextureShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_StrokeTextureShader", _wrap_delete_StrokeTextureShader, METH_VARARGS, NULL},
+	 { (char *)"StrokeTextureShader_swigregister", StrokeTextureShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_BackboneStretcherShader", _wrap_new_BackboneStretcherShader, METH_VARARGS, NULL},
+	 { (char *)"BackboneStretcherShader_shade", _wrap_BackboneStretcherShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_BackboneStretcherShader", _wrap_delete_BackboneStretcherShader, METH_VARARGS, NULL},
+	 { (char *)"BackboneStretcherShader_swigregister", BackboneStretcherShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_SamplingShader", _wrap_new_SamplingShader, METH_VARARGS, NULL},
+	 { (char *)"SamplingShader_shade", _wrap_SamplingShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_SamplingShader", _wrap_delete_SamplingShader, METH_VARARGS, NULL},
+	 { (char *)"SamplingShader_swigregister", SamplingShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_ExternalContourStretcherShader", _wrap_new_ExternalContourStretcherShader, METH_VARARGS, NULL},
+	 { (char *)"ExternalContourStretcherShader_shade", _wrap_ExternalContourStretcherShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_ExternalContourStretcherShader", _wrap_delete_ExternalContourStretcherShader, METH_VARARGS, NULL},
+	 { (char *)"ExternalContourStretcherShader_swigregister", ExternalContourStretcherShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_BSplineShader", _wrap_new_BSplineShader, METH_VARARGS, NULL},
+	 { (char *)"BSplineShader_shade", _wrap_BSplineShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_BSplineShader", _wrap_delete_BSplineShader, METH_VARARGS, NULL},
+	 { (char *)"BSplineShader_swigregister", BSplineShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_BezierCurveShader", _wrap_new_BezierCurveShader, METH_VARARGS, NULL},
+	 { (char *)"BezierCurveShader_shade", _wrap_BezierCurveShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_BezierCurveShader", _wrap_delete_BezierCurveShader, METH_VARARGS, NULL},
+	 { (char *)"BezierCurveShader_swigregister", BezierCurveShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_InflateShader", _wrap_new_InflateShader, METH_VARARGS, NULL},
+	 { (char *)"InflateShader_shade", _wrap_InflateShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_InflateShader", _wrap_delete_InflateShader, METH_VARARGS, NULL},
+	 { (char *)"InflateShader_swigregister", InflateShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_PolygonalizationShader", _wrap_new_PolygonalizationShader, METH_VARARGS, NULL},
+	 { (char *)"PolygonalizationShader_shade", _wrap_PolygonalizationShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_PolygonalizationShader", _wrap_delete_PolygonalizationShader, METH_VARARGS, NULL},
+	 { (char *)"PolygonalizationShader_swigregister", PolygonalizationShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_GuidingLinesShader", _wrap_new_GuidingLinesShader, METH_VARARGS, NULL},
+	 { (char *)"GuidingLinesShader_shade", _wrap_GuidingLinesShader_shade, METH_VARARGS, NULL},
+	 { (char *)"delete_GuidingLinesShader", _wrap_delete_GuidingLinesShader, METH_VARARGS, NULL},
+	 { (char *)"GuidingLinesShader_swigregister", GuidingLinesShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_TipRemoverShader", _wrap_new_TipRemoverShader, METH_VARARGS, NULL},
+	 { (char *)"delete_TipRemoverShader", _wrap_delete_TipRemoverShader, METH_VARARGS, NULL},
+	 { (char *)"TipRemoverShader_shade", _wrap_TipRemoverShader_shade, METH_VARARGS, NULL},
+	 { (char *)"TipRemoverShader_swigregister", TipRemoverShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"delete_streamShader", _wrap_delete_streamShader, METH_VARARGS, NULL},
+	 { (char *)"streamShader_getName", _wrap_streamShader_getName, METH_VARARGS, NULL},
+	 { (char *)"streamShader_shade", _wrap_streamShader_shade, METH_VARARGS, NULL},
+	 { (char *)"new_streamShader", _wrap_new_streamShader, METH_VARARGS, NULL},
+	 { (char *)"streamShader_swigregister", streamShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_fstreamShader", _wrap_new_fstreamShader, METH_VARARGS, NULL},
+	 { (char *)"delete_fstreamShader", _wrap_delete_fstreamShader, METH_VARARGS, NULL},
+	 { (char *)"fstreamShader_getName", _wrap_fstreamShader_getName, METH_VARARGS, NULL},
+	 { (char *)"fstreamShader_shade", _wrap_fstreamShader_shade, METH_VARARGS, NULL},
+	 { (char *)"fstreamShader_swigregister", fstreamShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_CalligraphicShader", _wrap_new_CalligraphicShader, METH_VARARGS, NULL},
+	 { (char *)"delete_CalligraphicShader", _wrap_delete_CalligraphicShader, METH_VARARGS, NULL},
+	 { (char *)"CalligraphicShader_shade", _wrap_CalligraphicShader_shade, METH_VARARGS, NULL},
+	 { (char *)"CalligraphicShader_swigregister", CalligraphicShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_SpatialNoiseShader", _wrap_new_SpatialNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"delete_SpatialNoiseShader", _wrap_delete_SpatialNoiseShader, METH_VARARGS, NULL},
+	 { (char *)"SpatialNoiseShader_shade", _wrap_SpatialNoiseShader_shade, METH_VARARGS, NULL},
+	 { (char *)"SpatialNoiseShader_swigregister", SpatialNoiseShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_SmoothingShader", _wrap_new_SmoothingShader, METH_VARARGS, NULL},
+	 { (char *)"delete_SmoothingShader", _wrap_delete_SmoothingShader, METH_VARARGS, NULL},
+	 { (char *)"SmoothingShader_shade", _wrap_SmoothingShader_shade, METH_VARARGS, NULL},
+	 { (char *)"SmoothingShader_swigregister", SmoothingShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Smoother", _wrap_new_Smoother, METH_VARARGS, NULL},
+	 { (char *)"delete_Smoother", _wrap_delete_Smoother, METH_VARARGS, NULL},
+	 { (char *)"Smoother_smooth", _wrap_Smoother_smooth, METH_VARARGS, NULL},
+	 { (char *)"Smoother_computeCurvature", _wrap_Smoother_computeCurvature, METH_VARARGS, NULL},
+	 { (char *)"Smoother_swigregister", Smoother_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_Omitter", _wrap_new_Omitter, METH_VARARGS, NULL},
+	 { (char *)"delete_Omitter", _wrap_delete_Omitter, METH_VARARGS, NULL},
+	 { (char *)"Omitter_omit", _wrap_Omitter_omit, METH_VARARGS, NULL},
+	 { (char *)"Omitter_swigregister", Omitter_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_OmissionShader", _wrap_new_OmissionShader, METH_VARARGS, NULL},
+	 { (char *)"delete_OmissionShader", _wrap_delete_OmissionShader, METH_VARARGS, NULL},
+	 { (char *)"OmissionShader_shade", _wrap_OmissionShader_shade, METH_VARARGS, NULL},
+	 { (char *)"OmissionShader_swigregister", OmissionShader_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Operators_select", _wrap_Operators_select, METH_VARARGS, NULL},
+	 { (char *)"Operators_chain", _wrap_Operators_chain, METH_VARARGS, NULL},
+	 { (char *)"Operators_bidirectionalChain", _wrap_Operators_bidirectionalChain, METH_VARARGS, NULL},
+	 { (char *)"Operators_sequentialSplit", _wrap_Operators_sequentialSplit, METH_VARARGS, NULL},
+	 { (char *)"Operators_recursiveSplit", _wrap_Operators_recursiveSplit, METH_VARARGS, NULL},
+	 { (char *)"Operators_sort", _wrap_Operators_sort, METH_VARARGS, NULL},
+	 { (char *)"Operators_create", _wrap_Operators_create, METH_VARARGS, NULL},
+	 { (char *)"Operators_getViewEdgeFromIndex", _wrap_Operators_getViewEdgeFromIndex, METH_VARARGS, NULL},
+	 { (char *)"Operators_getChainFromIndex", _wrap_Operators_getChainFromIndex, METH_VARARGS, NULL},
+	 { (char *)"Operators_getStrokeFromIndex", _wrap_Operators_getStrokeFromIndex, METH_VARARGS, NULL},
+	 { (char *)"Operators_getViewEdgesSize", _wrap_Operators_getViewEdgesSize, METH_VARARGS, NULL},
+	 { (char *)"Operators_getChainsSize", _wrap_Operators_getChainsSize, METH_VARARGS, NULL},
+	 { (char *)"Operators_getStrokesSize", _wrap_Operators_getStrokesSize, METH_VARARGS, NULL},
+	 { (char *)"delete_Operators", _wrap_delete_Operators, METH_VARARGS, NULL},
+	 { (char *)"Operators_swigregister", Operators_swigregister, METH_VARARGS, NULL},
+	 { (char *)"ltstr___call__", _wrap_ltstr___call__, METH_VARARGS, NULL},
+	 { (char *)"new_ltstr", _wrap_new_ltstr, METH_VARARGS, NULL},
+	 { (char *)"delete_ltstr", _wrap_delete_ltstr, METH_VARARGS, NULL},
+	 { (char *)"ltstr_swigregister", ltstr_swigregister, METH_VARARGS, NULL},
+	 { (char *)"Canvas_getInstance", _wrap_Canvas_getInstance, METH_VARARGS, NULL},
+	 { (char *)"delete_Canvas", _wrap_delete_Canvas, METH_VARARGS, NULL},
+	 { (char *)"Canvas_preDraw", _wrap_Canvas_preDraw, METH_VARARGS, NULL},
+	 { (char *)"Canvas_Draw", _wrap_Canvas_Draw, METH_VARARGS, NULL},
+	 { (char *)"Canvas_postDraw", _wrap_Canvas_postDraw, METH_VARARGS, NULL},
+	 { (char *)"Canvas_Render", _wrap_Canvas_Render, METH_VARARGS, NULL},
+	 { (char *)"Canvas_RenderBasic", _wrap_Canvas_RenderBasic, METH_VARARGS, NULL},
+	 { (char *)"Canvas_RenderStroke", _wrap_Canvas_RenderStroke, METH_VARARGS, NULL},
+	 { (char *)"Canvas_init", _wrap_Canvas_init, METH_VARARGS, NULL},
+	 { (char *)"Canvas_Clear", _wrap_Canvas_Clear, METH_VARARGS, NULL},
+	 { (char *)"Canvas_Erase", _wrap_Canvas_Erase, METH_VARARGS, NULL},
+	 { (char *)"Canvas_readColorPixels", _wrap_Canvas_readColorPixels, METH_VARARGS, NULL},
+	 { (char *)"Canvas_readDepthPixels", _wrap_Canvas_readDepthPixels, METH_VARARGS, NULL},
+	 { (char *)"Canvas_update", _wrap_Canvas_update, METH_VARARGS, NULL},
+	 { (char *)"Canvas_isEmpty", _wrap_Canvas_isEmpty, METH_VARARGS, NULL},
+	 { (char *)"Canvas_loadMap", _wrap_Canvas_loadMap, METH_VARARGS, NULL},
+	 { (char *)"Canvas_readMapPixel", _wrap_Canvas_readMapPixel, METH_VARARGS, NULL},
+	 { (char *)"Canvas_loadSteerableViewMap", _wrap_Canvas_loadSteerableViewMap, METH_VARARGS, NULL},
+	 { (char *)"Canvas_getSteerableViewMap", _wrap_Canvas_getSteerableViewMap, METH_VARARGS, NULL},
+	 { (char *)"Canvas_selectedFEdge", _wrap_Canvas_selectedFEdge, METH_VARARGS, NULL},
+	 { (char *)"Canvas_width", _wrap_Canvas_width, METH_VARARGS, NULL},
+	 { (char *)"Canvas_height", _wrap_Canvas_height, METH_VARARGS, NULL},
+	 { (char *)"Canvas_currentPaperTextureIndex", _wrap_Canvas_currentPaperTextureIndex, METH_VARARGS, NULL},
+	 { (char *)"Canvas_scene3DBBox", _wrap_Canvas_scene3DBBox, METH_VARARGS, NULL},
+	 { (char *)"Canvas_renderer", _wrap_Canvas_renderer, METH_VARARGS, NULL},
+	 { (char *)"Canvas_getCurrentStyleModule", _wrap_Canvas_getCurrentStyleModule, METH_VARARGS, NULL},
+	 { (char *)"Canvas_getRecordFlag", _wrap_Canvas_getRecordFlag, METH_VARARGS, NULL},
+	 { (char *)"Canvas_setSelectedFEdge", _wrap_Canvas_setSelectedFEdge, METH_VARARGS, NULL},
+	 { (char *)"Canvas_InsertStyleModule", _wrap_Canvas_InsertStyleModule, METH_VARARGS, NULL},
+	 { (char *)"Canvas_RemoveStyleModule", _wrap_Canvas_RemoveStyleModule, METH_VARARGS, NULL},
+	 { (char *)"Canvas_SwapStyleModules", _wrap_Canvas_SwapStyleModules, METH_VARARGS, NULL},
+	 { (char *)"Canvas_ReplaceStyleModule", _wrap_Canvas_ReplaceStyleModule, METH_VARARGS, NULL},
+	 { (char *)"Canvas_setVisible", _wrap_Canvas_setVisible, METH_VARARGS, NULL},
+	 { (char *)"Canvas_AddLayer", _wrap_Canvas_AddLayer, METH_VARARGS, NULL},
+	 { (char *)"Canvas_setCurrentPaperTextureIndex", _wrap_Canvas_setCurrentPaperTextureIndex, METH_VARARGS, NULL},
+	 { (char *)"Canvas_changePaperTexture", _wrap_Canvas_changePaperTexture, METH_VARARGS, NULL},
+	 { (char *)"Canvas_togglePaperTexture", _wrap_Canvas_togglePaperTexture, METH_VARARGS, NULL},
+	 { (char *)"Canvas_resetModified", _wrap_Canvas_resetModified, METH_VARARGS, NULL},
+	 { (char *)"Canvas_causalStyleModules", _wrap_Canvas_causalStyleModules, METH_VARARGS, NULL},
+	 { (char *)"Canvas_setModified", _wrap_Canvas_setModified, METH_VARARGS, NULL},
+	 { (char *)"Canvas_swigregister", Canvas_swigregister, METH_VARARGS, NULL},
+	 { (char *)"castToSVertex", _wrap_castToSVertex, METH_VARARGS, NULL},
+	 { (char *)"castToViewVertex", _wrap_castToViewVertex, METH_VARARGS, NULL},
+	 { (char *)"castToTVertex", _wrap_castToTVertex, METH_VARARGS, NULL},
+	 { (char *)"castToCurvePoint", _wrap_castToCurvePoint, METH_VARARGS, NULL},
+	 { (char *)"castToStrokeVertex", _wrap_castToStrokeVertex, METH_VARARGS, NULL},
+	 { (char *)"castToNonTVertex", _wrap_castToNonTVertex, METH_VARARGS, NULL},
+	 { (char *)"castToFEdge", _wrap_castToFEdge, METH_VARARGS, NULL},
+	 { (char *)"castToViewEdge", _wrap_castToViewEdge, METH_VARARGS, NULL},
+	 { (char *)"castToStroke", _wrap_castToStroke, METH_VARARGS, NULL},
+	 { (char *)"castToChain", _wrap_castToChain, METH_VARARGS, NULL},
+	 { NULL, NULL, 0, NULL }
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_Functions0D__GetOccludersF0DTo_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t(void *x) {
+    return (void *)((UnaryFunction0D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *)  ((Functions0D::GetOccludersF0D *) x));
+}
+static void *_p_Functions1D__GetOccludeeF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t(void *x) {
+    return (void *)((UnaryFunction1D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *)  ((Functions1D::GetOccludeeF1D *) x));
+}
+static void *_p_Functions1D__GetShapeF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t(void *x) {
+    return (void *)((UnaryFunction1D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *)  ((Functions1D::GetShapeF1D *) x));
+}
+static void *_p_Functions1D__GetOccludersF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t(void *x) {
+    return (void *)((UnaryFunction1D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *)  ((Functions1D::GetOccludersF1D *) x));
+}
+static void *_p_TVertexTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *) (ViewVertex *) ((TVertex *) x));
+}
+static void *_p_NonTVertexTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *) (ViewVertex *) ((NonTVertex *) x));
+}
+static void *_p_SVertexTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *)  ((SVertex *) x));
+}
+static void *_p_ViewVertexTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *)  ((ViewVertex *) x));
+}
+static void *_p_StrokeVertexTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *) (CurvePoint *) ((StrokeVertex *) x));
+}
+static void *_p_CurvePointTo_p_Interface0D(void *x) {
+    return (void *)((Interface0D *)  ((CurvePoint *) x));
+}
+static void *_p_Functions0D__GetShapeF0DTo_p_UnaryFunction0DTViewShape_p_t(void *x) {
+    return (void *)((UnaryFunction0D<ViewShape * > *)  ((Functions0D::GetShapeF0D *) x));
+}
+static void *_p_Functions0D__GetOccludeeF0DTo_p_UnaryFunction0DTViewShape_p_t(void *x) {
+    return (void *)((UnaryFunction0D<ViewShape * > *)  ((Functions0D::GetOccludeeF0D *) x));
+}
+static void *_p_ChainSilhouetteIteratorTo_p_ChainingIterator(void *x) {
+    return (void *)((ChainingIterator *)  ((ChainSilhouetteIterator *) x));
+}
+static void *_p_ChainPredicateIteratorTo_p_ChainingIterator(void *x) {
+    return (void *)((ChainingIterator *)  ((ChainPredicateIterator *) x));
+}
+static void *_p_ChainingIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator(void *x) {
+    return (void *)((ViewEdgeInternal::ViewEdgeIterator *)  ((ChainingIterator *) x));
+}
+static void *_p_ChainSilhouetteIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator(void *x) {
+    return (void *)((ViewEdgeInternal::ViewEdgeIterator *) (ChainingIterator *) ((ChainSilhouetteIterator *) x));
+}
+static void *_p_ChainPredicateIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator(void *x) {
+    return (void *)((ViewEdgeInternal::ViewEdgeIterator *) (ChainingIterator *) ((ChainPredicateIterator *) x));
+}
+static void *_p_ViewEdgeTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *)  ((ViewEdge *) x));
+}
+static void *_p_StrokeTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *)  ((Stroke *) x));
+}
+static void *_p_CurveTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *)  ((Curve *) x));
+}
+static void *_p_FEdgeSharpTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *) (FEdge *) ((FEdgeSharp *) x));
+}
+static void *_p_FEdgeSmoothTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *) (FEdge *) ((FEdgeSmooth *) x));
+}
+static void *_p_FEdgeTo_p_Interface1D(void *x) {
+    return (void *)((Interface1D *)  ((FEdge *) x));
+}
+static void *_p_VecMat__Vec2Tint_tTo_p_VecMat__VecTint_2_t(void *x) {
+    return (void *)((VecMat::Vec<int,2 > *)  ((VecMat::Vec2<int > *) x));
+}
+static void *_p_VecMat__Vec2Tunsigned_int_tTo_p_VecMat__VecTunsigned_int_2_t(void *x) {
+    return (void *)((VecMat::Vec<unsigned int,2 > *)  ((VecMat::Vec2<unsigned int > *) x));
+}
+static void *_p_VecMat__Vec3Tint_tTo_p_VecMat__VecTint_3_t(void *x) {
+    return (void *)((VecMat::Vec<int,3 > *)  ((VecMat::Vec3<int > *) x));
+}
+static void *_p_VecMat__Vec3Tunsigned_int_tTo_p_VecMat__VecTunsigned_int_3_t(void *x) {
+    return (void *)((VecMat::Vec<unsigned int,3 > *)  ((VecMat::Vec3<unsigned int > *) x));
+}
+static void *_p_StrokeVertexTo_p_CurvePoint(void *x) {
+    return (void *)((CurvePoint *)  ((StrokeVertex *) x));
+}
+static void *_p_Predicates0D__TrueUP0DTo_p_UnaryPredicate0D(void *x) {
+    return (void *)((UnaryPredicate0D *)  ((Predicates0D::TrueUP0D *) x));
+}
+static void *_p_Predicates0D__FalseUP0DTo_p_UnaryPredicate0D(void *x) {
+    return (void *)((UnaryPredicate0D *)  ((Predicates0D::FalseUP0D *) x));
+}
+static void *_p_FEdgeSharpTo_p_FEdge(void *x) {
+    return (void *)((FEdge *)  ((FEdgeSharp *) x));
+}
+static void *_p_FEdgeSmoothTo_p_FEdge(void *x) {
+    return (void *)((FEdge *)  ((FEdgeSmooth *) x));
+}
+static void *_p_StrokeShaders__ConstrainedIncreasingThicknessShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ConstrainedIncreasingThicknessShader *) x));
+}
+static void *_p_StrokeShaders__ColorNoiseShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ColorNoiseShader *) x));
+}
+static void *_p_StrokeShaders__ThicknessNoiseShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ThicknessNoiseShader *) x));
+}
+static void *_p_StrokeShaders__LengthDependingThicknessShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::LengthDependingThicknessShader *) x));
+}
+static void *_p_StrokeShaders__IncreasingThicknessShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::IncreasingThicknessShader *) x));
+}
+static void *_p_StrokeShaders__ConstantExternThicknessShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ConstantExternThicknessShader *) x));
+}
+static void *_p_StrokeShaders__ConstantThicknessShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ConstantThicknessShader *) x));
+}
+static void *_p_StrokeShaders__StrokeTextureShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::StrokeTextureShader *) x));
+}
+static void *_p_StrokeShaders__SamplingShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::SamplingShader *) x));
+}
+static void *_p_StrokeShaders__BSplineShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::BSplineShader *) x));
+}
+static void *_p_StrokeShaders__BezierCurveShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::BezierCurveShader *) x));
+}
+static void *_p_StrokeShaders__InflateShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::InflateShader *) x));
+}
+static void *_p_StrokeShaders__GuidingLinesShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::GuidingLinesShader *) x));
+}
+static void *_p_StrokeShaders__streamShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::streamShader *) x));
+}
+static void *_p_StrokeShaders__fstreamShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::fstreamShader *) x));
+}
+static void *_p_CalligraphicShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((CalligraphicShader *) x));
+}
+static void *_p_SpatialNoiseShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((SpatialNoiseShader *) x));
+}
+static void *_p_SmoothingShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((SmoothingShader *) x));
+}
+static void *_p_StrokeShaders__TextureAssignerShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::TextureAssignerShader *) x));
+}
+static void *_p_StrokeShaders__CalligraphicColorShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::CalligraphicColorShader *) x));
+}
+static void *_p_StrokeShaders__MaterialColorShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::MaterialColorShader *) x));
+}
+static void *_p_StrokeShaders__ColorVariationPatternShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ColorVariationPatternShader *) x));
+}
+static void *_p_StrokeShaders__IncreasingColorShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::IncreasingColorShader *) x));
+}
+static void *_p_StrokeShaders__ConstantColorShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ConstantColorShader *) x));
+}
+static void *_p_StrokeShaders__ThicknessVariationPatternShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ThicknessVariationPatternShader *) x));
+}
+static void *_p_StrokeShaders__BackboneStretcherShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::BackboneStretcherShader *) x));
+}
+static void *_p_StrokeShaders__ExternalContourStretcherShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::ExternalContourStretcherShader *) x));
+}
+static void *_p_StrokeShaders__PolygonalizationShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::PolygonalizationShader *) x));
+}
+static void *_p_StrokeShaders__TipRemoverShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((StrokeShaders::TipRemoverShader *) x));
+}
+static void *_p_OmissionShaderTo_p_StrokeShader(void *x) {
+    return (void *)((StrokeShader *)  ((OmissionShader *) x));
+}
+static void *_p_OmitterTo_p_Smoother(void *x) {
+    return (void *)((Smoother *)  ((Omitter *) x));
+}
+static void *_p_Predicates1D__Length2DBP1DTo_p_BinaryPredicate1D(void *x) {
+    return (void *)((BinaryPredicate1D *)  ((Predicates1D::Length2DBP1D *) x));
+}
+static void *_p_Predicates1D__FalseBP1DTo_p_BinaryPredicate1D(void *x) {
+    return (void *)((BinaryPredicate1D *)  ((Predicates1D::FalseBP1D *) x));
+}
+static void *_p_Predicates1D__ViewMapGradientNormBP1DTo_p_BinaryPredicate1D(void *x) {
+    return (void *)((BinaryPredicate1D *)  ((Predicates1D::ViewMapGradientNormBP1D *) x));
+}
+static void *_p_Predicates1D__TrueBP1DTo_p_BinaryPredicate1D(void *x) {
+    return (void *)((BinaryPredicate1D *)  ((Predicates1D::TrueBP1D *) x));
+}
+static void *_p_Predicates1D__SameShapeIdBP1DTo_p_BinaryPredicate1D(void *x) {
+    return (void *)((BinaryPredicate1D *)  ((Predicates1D::SameShapeIdBP1D *) x));
+}
+static void *_p_Predicates1D__FalseUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::FalseUP1D *) x));
+}
+static void *_p_Predicates1D__ShapeUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::ShapeUP1D *) x));
+}
+static void *_p_Predicates1D__DensityLowerThanUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::DensityLowerThanUP1D *) x));
+}
+static void *_p_Predicates1D__EqualToTimeStampUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::EqualToTimeStampUP1D *) x));
+}
+static void *_p_Predicates1D__EqualToChainingTimeStampUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::EqualToChainingTimeStampUP1D *) x));
+}
+static void *_p_Predicates1D__TrueUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::TrueUP1D *) x));
+}
+static void *_p_Predicates1D__QuantitativeInvisibilityUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::QuantitativeInvisibilityUP1D *) x));
+}
+static void *_p_Predicates1D__ContourUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::ContourUP1D *) x));
+}
+static void *_p_Predicates1D__ExternalContourUP1DTo_p_UnaryPredicate1D(void *x) {
+    return (void *)((UnaryPredicate1D *)  ((Predicates1D::ExternalContourUP1D *) x));
+}
+static void *_p_VecMat__Vec2Tfloat_tTo_p_VecMat__VecTfloat_2_t(void *x) {
+    return (void *)((VecMat::Vec<float,2 > *)  ((VecMat::Vec2<float > *) x));
+}
+static void *_p_Functions1D__TimeStampF1DTo_p_UnaryFunction1DTvoid_t(void *x) {
+    return (void *)((UnaryFunction1D<void > *)  ((Functions1D::TimeStampF1D *) x));
+}
+static void *_p_Functions1D__IncrementChainingTimeStampF1DTo_p_UnaryFunction1DTvoid_t(void *x) {
+    return (void *)((UnaryFunction1D<void > *)  ((Functions1D::IncrementChainingTimeStampF1D *) x));
+}
+static void *_p_Functions1D__ChainingTimeStampF1DTo_p_UnaryFunction1DTvoid_t(void *x) {
+    return (void *)((UnaryFunction1D<void > *)  ((Functions1D::ChainingTimeStampF1D *) x));
+}
+static void *_p_VecMat__Vec3Tfloat_tTo_p_VecMat__VecTfloat_3_t(void *x) {
+    return (void *)((VecMat::Vec<float,3 > *)  ((VecMat::Vec3<float > *) x));
+}
+static void *_p_FEdgeInternal__SVertexIteratorTo_p_Interface0DIteratorNested(void *x) {
+    return (void *)((Interface0DIteratorNested *)  ((FEdgeInternal::SVertexIterator *) x));
+}
+static void *_p_ViewEdgeInternal__SVertexIteratorTo_p_Interface0DIteratorNested(void *x) {
+    return (void *)((Interface0DIteratorNested *)  ((ViewEdgeInternal::SVertexIterator *) x));
+}
+static void *_p_CurveInternal__CurvePointIteratorTo_p_Interface0DIteratorNested(void *x) {
+    return (void *)((Interface0DIteratorNested *)  ((CurveInternal::CurvePointIterator *) x));
+}
+static void *_p_StrokeInternal__StrokeVertexIteratorTo_p_Interface0DIteratorNested(void *x) {
+    return (void *)((Interface0DIteratorNested *)  ((StrokeInternal::StrokeVertexIterator *) x));
+}
+static void *_p_Functions0D__VertexOrientation2DF0DTo_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction0D<VecMat::Vec2<float > > *)  ((Functions0D::VertexOrientation2DF0D *) x));
+}
+static void *_p_Functions0D__Normal2DF0DTo_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction0D<VecMat::Vec2<float > > *)  ((Functions0D::Normal2DF0D *) x));
+}
+static void *_p_Functions0D__VertexOrientation3DF0DTo_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction0D<VecMat::Vec3<float > > *)  ((Functions0D::VertexOrientation3DF0D *) x));
+}
+static void *_p_Functions1D__Orientation2DF1DTo_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction1D<VecMat::Vec2<float > > *)  ((Functions1D::Orientation2DF1D *) x));
+}
+static void *_p_Functions1D__Normal2DF1DTo_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction1D<VecMat::Vec2<float > > *)  ((Functions1D::Normal2DF1D *) x));
+}
+static void *_p_Functions1D__Orientation3DF1DTo_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t(void *x) {
+    return (void *)((UnaryFunction1D<VecMat::Vec3<float > > *)  ((Functions1D::Orientation3DF1D *) x));
+}
+static void *_p_Functions0D__QuantitativeInvisibilityF0DTo_p_UnaryFunction0DTunsigned_int_t(void *x) {
+    return (void *)((UnaryFunction0D<unsigned int > *)  ((Functions0D::QuantitativeInvisibilityF0D *) x));
+}
+static void *_p_Functions1D__QuantitativeInvisibilityF1DTo_p_UnaryFunction1DTunsigned_int_t(void *x) {
+    return (void *)((UnaryFunction1D<unsigned int > *)  ((Functions1D::QuantitativeInvisibilityF1D *) x));
+}
+static void *_p_Functions0D__ShapeIdF0DTo_p_UnaryFunction0DTId_t(void *x) {
+    return (void *)((UnaryFunction0D<Id > *)  ((Functions0D::ShapeIdF0D *) x));
+}
+static void *_p_VecMat__Vec2Tdouble_tTo_p_VecMat__VecTdouble_2_t(void *x) {
+    return (void *)((VecMat::Vec<double,2 > *)  ((VecMat::Vec2<double > *) x));
+}
+static void *_p_TVertexTo_p_ViewVertex(void *x) {
+    return (void *)((ViewVertex *)  ((TVertex *) x));
+}
+static void *_p_NonTVertexTo_p_ViewVertex(void *x) {
+    return (void *)((ViewVertex *)  ((NonTVertex *) x));
+}
+static void *_p_Functions0D__ZDiscontinuityF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::ZDiscontinuityF0D *) x));
+}
+static void *_p_Functions0D__DensityF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::DensityF0D *) x));
+}
+static void *_p_Functions0D__GetXF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetXF0D *) x));
+}
+static void *_p_Functions0D__GetProjectedXF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetProjectedXF0D *) x));
+}
+static void *_p_Functions0D__Curvature2DAngleF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::Curvature2DAngleF0D *) x));
+}
+static void *_p_Functions0D__GetYF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetYF0D *) x));
+}
+static void *_p_Functions0D__GetProjectedYF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetProjectedYF0D *) x));
+}
+static void *_p_Functions0D__GetZF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetZF0D *) x));
+}
+static void *_p_Functions0D__GetProjectedZF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::GetProjectedZF0D *) x));
+}
+static void *_p_Functions0D__LocalAverageDepthF0DTo_p_UnaryFunction0DTdouble_t(void *x) {
+    return (void *)((UnaryFunction0D<double > *)  ((Functions0D::LocalAverageDepthF0D *) x));
+}
+static void *_p_Functions1D__GetSteerableViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetSteerableViewMapDensityF1D *) x));
+}
+static void *_p_Functions1D__GetDirectionalViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetDirectionalViewMapDensityF1D *) x));
+}
+static void *_p_Functions1D__GetCompleteViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetCompleteViewMapDensityF1D *) x));
+}
+static void *_p_Functions1D__DensityF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::DensityF1D *) x));
+}
+static void *_p_Functions1D__ZDiscontinuityF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::ZDiscontinuityF1D *) x));
+}
+static void *_p_Functions1D__GetXF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetXF1D *) x));
+}
+static void *_p_Functions1D__GetZF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetZF1D *) x));
+}
+static void *_p_Functions1D__GetViewMapGradientNormF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetViewMapGradientNormF1D *) x));
+}
+static void *_p_Functions1D__GetProjectedYF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetProjectedYF1D *) x));
+}
+static void *_p_Functions1D__Curvature2DAngleF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::Curvature2DAngleF1D *) x));
+}
+static void *_p_Functions1D__GetYF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetYF1D *) x));
+}
+static void *_p_Functions1D__GetProjectedXF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetProjectedXF1D *) x));
+}
+static void *_p_Functions1D__LocalAverageDepthF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::LocalAverageDepthF1D *) x));
+}
+static void *_p_Functions1D__GetProjectedZF1DTo_p_UnaryFunction1DTdouble_t(void *x) {
+    return (void *)((UnaryFunction1D<double > *)  ((Functions1D::GetProjectedZF1D *) x));
+}
+static void *_p_Functions0D__GetCurvilinearAbscissaF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::GetCurvilinearAbscissaF0D *) x));
+}
+static void *_p_Functions0D__ReadMapPixelF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::ReadMapPixelF0D *) x));
+}
+static void *_p_Functions0D__ReadSteerableViewMapPixelF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::ReadSteerableViewMapPixelF0D *) x));
+}
+static void *_p_Functions0D__ReadCompleteViewMapPixelF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::ReadCompleteViewMapPixelF0D *) x));
+}
+static void *_p_Functions0D__GetViewMapGradientNormF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::GetViewMapGradientNormF0D *) x));
+}
+static void *_p_Functions0D__GetParameterF0DTo_p_UnaryFunction0DTfloat_t(void *x) {
+    return (void *)((UnaryFunction0D<float > *)  ((Functions0D::GetParameterF0D *) x));
+}
+static void *_p_VecMat__Vec3Tdouble_tTo_p_VecMat__VecTdouble_3_t(void *x) {
+    return (void *)((VecMat::Vec<double,3 > *)  ((VecMat::Vec3<double > *) x));
+}
+static swig_type_info _swigt__p_AdjacencyIterator = {"_p_AdjacencyIterator", "AdjacencyIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_BBoxTVecMat__Vec3Tdouble_t_t = {"_p_BBoxTVecMat__Vec3Tdouble_t_t", "BBox<VecMat::Vec3<double > > *|BBox<Geometry::Vec3r > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_BinaryPredicate0D = {"_p_BinaryPredicate0D", "BinaryPredicate0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_BinaryPredicate1D = {"_p_BinaryPredicate1D", "BinaryPredicate1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CalligraphicShader = {"_p_CalligraphicShader", "CalligraphicShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Canvas = {"_p_Canvas", "Canvas *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Chain = {"_p_Chain", "Chain *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ChainPredicateIterator = {"_p_ChainPredicateIterator", "ChainPredicateIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ChainSilhouetteIterator = {"_p_ChainSilhouetteIterator", "ChainSilhouetteIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ChainingIterator = {"_p_ChainingIterator", "ChainingIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CurvatureInfo = {"_p_CurvatureInfo", "CurvatureInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Curve = {"_p_Curve", "Curve *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CurveInternal__CurvePointIterator = {"_p_CurveInternal__CurvePointIterator", "CurveInternal::CurvePointIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CurvePoint = {"_p_CurvePoint", "CurvePoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Curve__vertex_container__iterator = {"_p_Curve__vertex_container__iterator", "::Curve::vertex_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FEdge = {"_p_FEdge", "FEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FEdgeInternal__SVertexIterator = {"_p_FEdgeInternal__SVertexIterator", "FEdgeInternal::SVertexIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FEdgeSharp = {"_p_FEdgeSharp", "FEdgeSharp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FEdgeSmooth = {"_p_FEdgeSmooth", "FEdgeSmooth *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__Curvature2DAngleF0D = {"_p_Functions0D__Curvature2DAngleF0D", "Functions0D::Curvature2DAngleF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__CurveNatureF0D = {"_p_Functions0D__CurveNatureF0D", "Functions0D::CurveNatureF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__DensityF0D = {"_p_Functions0D__DensityF0D", "Functions0D::DensityF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetCurvilinearAbscissaF0D = {"_p_Functions0D__GetCurvilinearAbscissaF0D", "Functions0D::GetCurvilinearAbscissaF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetOccludeeF0D = {"_p_Functions0D__GetOccludeeF0D", "Functions0D::GetOccludeeF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetOccludersF0D = {"_p_Functions0D__GetOccludersF0D", "Functions0D::GetOccludersF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetParameterF0D = {"_p_Functions0D__GetParameterF0D", "Functions0D::GetParameterF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetProjectedXF0D = {"_p_Functions0D__GetProjectedXF0D", "Functions0D::GetProjectedXF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetProjectedYF0D = {"_p_Functions0D__GetProjectedYF0D", "Functions0D::GetProjectedYF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetProjectedZF0D = {"_p_Functions0D__GetProjectedZF0D", "Functions0D::GetProjectedZF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetShapeF0D = {"_p_Functions0D__GetShapeF0D", "Functions0D::GetShapeF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetViewMapGradientNormF0D = {"_p_Functions0D__GetViewMapGradientNormF0D", "Functions0D::GetViewMapGradientNormF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetXF0D = {"_p_Functions0D__GetXF0D", "Functions0D::GetXF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetYF0D = {"_p_Functions0D__GetYF0D", "Functions0D::GetYF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__GetZF0D = {"_p_Functions0D__GetZF0D", "Functions0D::GetZF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__LocalAverageDepthF0D = {"_p_Functions0D__LocalAverageDepthF0D", "Functions0D::LocalAverageDepthF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__MaterialF0D = {"_p_Functions0D__MaterialF0D", "Functions0D::MaterialF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__Normal2DF0D = {"_p_Functions0D__Normal2DF0D", "Functions0D::Normal2DF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__QuantitativeInvisibilityF0D = {"_p_Functions0D__QuantitativeInvisibilityF0D", "Functions0D::QuantitativeInvisibilityF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__ReadCompleteViewMapPixelF0D = {"_p_Functions0D__ReadCompleteViewMapPixelF0D", "Functions0D::ReadCompleteViewMapPixelF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__ReadMapPixelF0D = {"_p_Functions0D__ReadMapPixelF0D", "Functions0D::ReadMapPixelF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__ReadSteerableViewMapPixelF0D = {"_p_Functions0D__ReadSteerableViewMapPixelF0D", "Functions0D::ReadSteerableViewMapPixelF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__ShapeIdF0D = {"_p_Functions0D__ShapeIdF0D", "Functions0D::ShapeIdF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__VertexOrientation2DF0D = {"_p_Functions0D__VertexOrientation2DF0D", "Functions0D::VertexOrientation2DF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__VertexOrientation3DF0D = {"_p_Functions0D__VertexOrientation3DF0D", "Functions0D::VertexOrientation3DF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions0D__ZDiscontinuityF0D = {"_p_Functions0D__ZDiscontinuityF0D", "Functions0D::ZDiscontinuityF0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__ChainingTimeStampF1D = {"_p_Functions1D__ChainingTimeStampF1D", "Functions1D::ChainingTimeStampF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__Curvature2DAngleF1D = {"_p_Functions1D__Curvature2DAngleF1D", "Functions1D::Curvature2DAngleF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__CurveNatureF1D = {"_p_Functions1D__CurveNatureF1D", "Functions1D::CurveNatureF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__DensityF1D = {"_p_Functions1D__DensityF1D", "Functions1D::DensityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetCompleteViewMapDensityF1D = {"_p_Functions1D__GetCompleteViewMapDensityF1D", "Functions1D::GetCompleteViewMapDensityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetDirectionalViewMapDensityF1D = {"_p_Functions1D__GetDirectionalViewMapDensityF1D", "Functions1D::GetDirectionalViewMapDensityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetOccludeeF1D = {"_p_Functions1D__GetOccludeeF1D", "Functions1D::GetOccludeeF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetOccludersF1D = {"_p_Functions1D__GetOccludersF1D", "Functions1D::GetOccludersF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetProjectedXF1D = {"_p_Functions1D__GetProjectedXF1D", "Functions1D::GetProjectedXF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetProjectedYF1D = {"_p_Functions1D__GetProjectedYF1D", "Functions1D::GetProjectedYF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetProjectedZF1D = {"_p_Functions1D__GetProjectedZF1D", "Functions1D::GetProjectedZF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetShapeF1D = {"_p_Functions1D__GetShapeF1D", "Functions1D::GetShapeF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetSteerableViewMapDensityF1D = {"_p_Functions1D__GetSteerableViewMapDensityF1D", "Functions1D::GetSteerableViewMapDensityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetViewMapGradientNormF1D = {"_p_Functions1D__GetViewMapGradientNormF1D", "Functions1D::GetViewMapGradientNormF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetXF1D = {"_p_Functions1D__GetXF1D", "Functions1D::GetXF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetYF1D = {"_p_Functions1D__GetYF1D", "Functions1D::GetYF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__GetZF1D = {"_p_Functions1D__GetZF1D", "Functions1D::GetZF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__IncrementChainingTimeStampF1D = {"_p_Functions1D__IncrementChainingTimeStampF1D", "Functions1D::IncrementChainingTimeStampF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__LocalAverageDepthF1D = {"_p_Functions1D__LocalAverageDepthF1D", "Functions1D::LocalAverageDepthF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__Normal2DF1D = {"_p_Functions1D__Normal2DF1D", "Functions1D::Normal2DF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__Orientation2DF1D = {"_p_Functions1D__Orientation2DF1D", "Functions1D::Orientation2DF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__Orientation3DF1D = {"_p_Functions1D__Orientation3DF1D", "Functions1D::Orientation3DF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__QuantitativeInvisibilityF1D = {"_p_Functions1D__QuantitativeInvisibilityF1D", "Functions1D::QuantitativeInvisibilityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__TimeStampF1D = {"_p_Functions1D__TimeStampF1D", "Functions1D::TimeStampF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Functions1D__ZDiscontinuityF1D = {"_p_Functions1D__ZDiscontinuityF1D", "Functions1D::ZDiscontinuityF1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_GrayImage = {"_p_GrayImage", "GrayImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_I1DContainer = {"_p_I1DContainer", "I1DContainer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Id = {"_p_Id", "Id *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_IntegrationType = {"_p_IntegrationType", "enum IntegrationType *|IntegrationType *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Interface0D = {"_p_Interface0D", "Interface0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Interface0DIterator = {"_p_Interface0DIterator", "Interface0DIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Interface0DIteratorNested = {"_p_Interface0DIteratorNested", "Interface0DIteratorNested *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Interface1D = {"_p_Interface1D", "Interface1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Material = {"_p_Material", "Material *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_MediumType = {"_p_MediumType", "MediumType *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Module = {"_p_Module", "Module *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Noise = {"_p_Noise", "Noise *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_NonTVertex = {"_p_NonTVertex", "NonTVertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_OmissionShader = {"_p_OmissionShader", "OmissionShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Omitter = {"_p_Omitter", "Omitter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Operators = {"_p_Operators", "Operators *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Point = {"_p_Point", "Point *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Polygon3r = {"_p_Polygon3r", "Polygon3r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates0D__FalseUP0D = {"_p_Predicates0D__FalseUP0D", "Predicates0D::FalseUP0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates0D__TrueUP0D = {"_p_Predicates0D__TrueUP0D", "Predicates0D::TrueUP0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__ContourUP1D = {"_p_Predicates1D__ContourUP1D", "Predicates1D::ContourUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__DensityLowerThanUP1D = {"_p_Predicates1D__DensityLowerThanUP1D", "Predicates1D::DensityLowerThanUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__EqualToChainingTimeStampUP1D = {"_p_Predicates1D__EqualToChainingTimeStampUP1D", "Predicates1D::EqualToChainingTimeStampUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__EqualToTimeStampUP1D = {"_p_Predicates1D__EqualToTimeStampUP1D", "Predicates1D::EqualToTimeStampUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__ExternalContourUP1D = {"_p_Predicates1D__ExternalContourUP1D", "Predicates1D::ExternalContourUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__FalseBP1D = {"_p_Predicates1D__FalseBP1D", "Predicates1D::FalseBP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__FalseUP1D = {"_p_Predicates1D__FalseUP1D", "Predicates1D::FalseUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__Length2DBP1D = {"_p_Predicates1D__Length2DBP1D", "Predicates1D::Length2DBP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__QuantitativeInvisibilityUP1D = {"_p_Predicates1D__QuantitativeInvisibilityUP1D", "Predicates1D::QuantitativeInvisibilityUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__SameShapeIdBP1D = {"_p_Predicates1D__SameShapeIdBP1D", "Predicates1D::SameShapeIdBP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__ShapeUP1D = {"_p_Predicates1D__ShapeUP1D", "Predicates1D::ShapeUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__TrueBP1D = {"_p_Predicates1D__TrueBP1D", "Predicates1D::TrueBP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__TrueUP1D = {"_p_Predicates1D__TrueUP1D", "Predicates1D::TrueUP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Predicates1D__ViewMapGradientNormBP1D = {"_p_Predicates1D__ViewMapGradientNormBP1D", "Predicates1D::ViewMapGradientNormBP1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_RGBImage = {"_p_RGBImage", "RGBImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ReturnedValueType = {"_p_ReturnedValueType", "ReturnedValueType *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SShape = {"_p_SShape", "SShape *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SVertex = {"_p_SVertex", "SVertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SVertex__fedges_container__iterator = {"_p_SVertex__fedges_container__iterator", "SVertex::fedges_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Smoother = {"_p_Smoother", "Smoother *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SmoothingShader = {"_p_SmoothingShader", "SmoothingShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SpatialNoiseShader = {"_p_SpatialNoiseShader", "SpatialNoiseShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SteerableViewMap = {"_p_SteerableViewMap", "SteerableViewMap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Stroke = {"_p_Stroke", "Stroke *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeAttribute = {"_p_StrokeAttribute", "StrokeAttribute *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeInternal__StrokeVertexIterator = {"_p_StrokeInternal__StrokeVertexIterator", "StrokeInternal::StrokeVertexIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeLayer = {"_p_StrokeLayer", "StrokeLayer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeRenderer = {"_p_StrokeRenderer", "StrokeRenderer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShader = {"_p_StrokeShader", "StrokeShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__BSplineShader = {"_p_StrokeShaders__BSplineShader", "StrokeShaders::BSplineShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__BackboneStretcherShader = {"_p_StrokeShaders__BackboneStretcherShader", "StrokeShaders::BackboneStretcherShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__BezierCurveShader = {"_p_StrokeShaders__BezierCurveShader", "StrokeShaders::BezierCurveShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__CalligraphicColorShader = {"_p_StrokeShaders__CalligraphicColorShader", "StrokeShaders::CalligraphicColorShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ColorNoiseShader = {"_p_StrokeShaders__ColorNoiseShader", "StrokeShaders::ColorNoiseShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ColorVariationPatternShader = {"_p_StrokeShaders__ColorVariationPatternShader", "StrokeShaders::ColorVariationPatternShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ConstantColorShader = {"_p_StrokeShaders__ConstantColorShader", "StrokeShaders::ConstantColorShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ConstantExternThicknessShader = {"_p_StrokeShaders__ConstantExternThicknessShader", "StrokeShaders::ConstantExternThicknessShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ConstantThicknessShader = {"_p_StrokeShaders__ConstantThicknessShader", "StrokeShaders::ConstantThicknessShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ConstrainedIncreasingThicknessShader = {"_p_StrokeShaders__ConstrainedIncreasingThicknessShader", "StrokeShaders::ConstrainedIncreasingThicknessShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ExternalContourStretcherShader = {"_p_StrokeShaders__ExternalContourStretcherShader", "StrokeShaders::ExternalContourStretcherShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__GuidingLinesShader = {"_p_StrokeShaders__GuidingLinesShader", "StrokeShaders::GuidingLinesShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__IncreasingColorShader = {"_p_StrokeShaders__IncreasingColorShader", "StrokeShaders::IncreasingColorShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__IncreasingThicknessShader = {"_p_StrokeShaders__IncreasingThicknessShader", "StrokeShaders::IncreasingThicknessShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__InflateShader = {"_p_StrokeShaders__InflateShader", "StrokeShaders::InflateShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__LengthDependingThicknessShader = {"_p_StrokeShaders__LengthDependingThicknessShader", "StrokeShaders::LengthDependingThicknessShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__MaterialColorShader = {"_p_StrokeShaders__MaterialColorShader", "StrokeShaders::MaterialColorShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__PolygonalizationShader = {"_p_StrokeShaders__PolygonalizationShader", "StrokeShaders::PolygonalizationShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__SamplingShader = {"_p_StrokeShaders__SamplingShader", "StrokeShaders::SamplingShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__StrokeTextureShader = {"_p_StrokeShaders__StrokeTextureShader", "StrokeShaders::StrokeTextureShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__TextureAssignerShader = {"_p_StrokeShaders__TextureAssignerShader", "StrokeShaders::TextureAssignerShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ThicknessNoiseShader = {"_p_StrokeShaders__ThicknessNoiseShader", "StrokeShaders::ThicknessNoiseShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__ThicknessVariationPatternShader = {"_p_StrokeShaders__ThicknessVariationPatternShader", "StrokeShaders::ThicknessVariationPatternShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__TipRemoverShader = {"_p_StrokeShaders__TipRemoverShader", "StrokeShaders::TipRemoverShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__fstreamShader = {"_p_StrokeShaders__fstreamShader", "StrokeShaders::fstreamShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeShaders__streamShader = {"_p_StrokeShaders__streamShader", "StrokeShaders::streamShader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokeVertex = {"_p_StrokeVertex", "StrokeVertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Stroke__vertex_container__iterator = {"_p_Stroke__vertex_container__iterator", "Stroke::vertex_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Stroke__viewedge_container__const_iterator = {"_p_Stroke__viewedge_container__const_iterator", "Stroke::viewedge_container::const_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Stroke__viewedge_container__iterator = {"_p_Stroke__viewedge_container__iterator", "Stroke::viewedge_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StrokesContainer = {"_p_StrokesContainer", "StrokesContainer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_StyleModule = {"_p_StyleModule", "StyleModule *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TVertex = {"_p_TVertex", "TVertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTId_t = {"_p_UnaryFunction0DTId_t", "UnaryFunction0D<Id > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t = {"_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t", "UnaryFunction0D<VecMat::Vec2<float > > *|UnaryFunction0D<Geometry::Vec2f > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t = {"_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t", "UnaryFunction0D<VecMat::Vec3<float > > *|UnaryFunction0D<Geometry::Vec3f > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTViewShape_p_t = {"_p_UnaryFunction0DTViewShape_p_t", "UnaryFunction0D<ViewShape * > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTdouble_t = {"_p_UnaryFunction0DTdouble_t", "UnaryFunction0D<double > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTfloat_t = {"_p_UnaryFunction0DTfloat_t", "UnaryFunction0D<float > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t = {"_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t", "UnaryFunction0D<std::vector<ViewShape * > > *|UnaryFunction0D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTunsigned_int_t = {"_p_UnaryFunction0DTunsigned_int_t", "UnaryFunction0D<unsigned int > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction0DTvoid_t = {"_p_UnaryFunction0DTvoid_t", "UnaryFunction0D<void > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t = {"_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t", "UnaryFunction1D<VecMat::Vec2<float > > *|UnaryFunction1D<Geometry::Vec2f > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t = {"_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t", "UnaryFunction1D<VecMat::Vec3<float > > *|UnaryFunction1D<Geometry::Vec3f > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTdouble_t = {"_p_UnaryFunction1DTdouble_t", "UnaryFunction1D<double > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTfloat_t = {"_p_UnaryFunction1DTfloat_t", "UnaryFunction1D<float > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t = {"_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t", "UnaryFunction1D<std::vector<ViewShape * > > *|UnaryFunction1D<std::vector<ViewShape *,std::allocator<ViewShape * > > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTunsigned_int_t = {"_p_UnaryFunction1DTunsigned_int_t", "UnaryFunction1D<unsigned int > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryFunction1DTvoid_t = {"_p_UnaryFunction1DTvoid_t", "UnaryFunction1D<void > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryPredicate0D = {"_p_UnaryPredicate0D", "UnaryPredicate0D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UnaryPredicate1D = {"_p_UnaryPredicate1D", "UnaryPredicate1D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__HVec3Tdouble_t = {"_p_VecMat__HVec3Tdouble_t", "VecMat::HVec3<double > *|Geometry::HVec3r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__HVec3Tfloat_t = {"_p_VecMat__HVec3Tfloat_t", "VecMat::HVec3<float > *|Geometry::HVec3f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__HVec3Tint_t = {"_p_VecMat__HVec3Tint_t", "VecMat::HVec3<int > *|Geometry::HVec3i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__HVec3Tunsigned_int_t = {"_p_VecMat__HVec3Tunsigned_int_t", "VecMat::HVec3<unsigned int > *|Geometry::HVec3u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTdouble_2_t = {"_p_VecMat__SquareMatrixTdouble_2_t", "VecMat::SquareMatrix<double,2 > *|Geometry::Matrix22r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTdouble_3_t = {"_p_VecMat__SquareMatrixTdouble_3_t", "VecMat::SquareMatrix<double,3 > *|Geometry::Matrix33r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTdouble_4_t = {"_p_VecMat__SquareMatrixTdouble_4_t", "VecMat::SquareMatrix<double,4 > *|Geometry::Matrix44r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTfloat_2_t = {"_p_VecMat__SquareMatrixTfloat_2_t", "VecMat::SquareMatrix<float,2 > *|Geometry::Matrix22f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTfloat_3_t = {"_p_VecMat__SquareMatrixTfloat_3_t", "VecMat::SquareMatrix<float,3 > *|Geometry::Matrix33f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTfloat_4_t = {"_p_VecMat__SquareMatrixTfloat_4_t", "VecMat::SquareMatrix<float,4 > *|Geometry::Matrix44f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTint_2_t = {"_p_VecMat__SquareMatrixTint_2_t", "VecMat::SquareMatrix<int,2 > *|Geometry::Matrix22i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTint_3_t = {"_p_VecMat__SquareMatrixTint_3_t", "VecMat::SquareMatrix<int,3 > *|Geometry::Matrix33i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTint_4_t = {"_p_VecMat__SquareMatrixTint_4_t", "VecMat::SquareMatrix<int,4 > *|Geometry::Matrix44i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTunsigned_int_2_t = {"_p_VecMat__SquareMatrixTunsigned_int_2_t", "VecMat::SquareMatrix<unsigned int,2 > *|Geometry::Matrix22u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTunsigned_int_3_t = {"_p_VecMat__SquareMatrixTunsigned_int_3_t", "VecMat::SquareMatrix<unsigned int,3 > *|Geometry::Matrix33u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__SquareMatrixTunsigned_int_4_t = {"_p_VecMat__SquareMatrixTunsigned_int_4_t", "VecMat::SquareMatrix<unsigned int,4 > *|Geometry::Matrix44u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec2Tdouble_t = {"_p_VecMat__Vec2Tdouble_t", "VecMat::Vec2<double > *|Geometry::Vec2d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec2Tfloat_t = {"_p_VecMat__Vec2Tfloat_t", "VecMat::Vec2<float > *|Geometry::Vec2f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec2Tint_t = {"_p_VecMat__Vec2Tint_t", "VecMat::Vec2<int > *|Geometry::Vec2i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec2Tunsigned_int_t = {"_p_VecMat__Vec2Tunsigned_int_t", "VecMat::Vec2<unsigned int > *|Geometry::Vec2u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec3Tdouble_t = {"_p_VecMat__Vec3Tdouble_t", "VecMat::Vec3<double > *|Geometry::Vec3r *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec3Tfloat_t = {"_p_VecMat__Vec3Tfloat_t", "VecMat::Vec3<float > *|Geometry::Vec3f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec3Tint_t = {"_p_VecMat__Vec3Tint_t", "VecMat::Vec3<int > *|Geometry::Vec3i *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__Vec3Tunsigned_int_t = {"_p_VecMat__Vec3Tunsigned_int_t", "VecMat::Vec3<unsigned int > *|Geometry::Vec3u *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTdouble_2_t = {"_p_VecMat__VecTdouble_2_t", "VecMat::Vec<double,2 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTdouble_3_t = {"_p_VecMat__VecTdouble_3_t", "VecMat::Vec<double,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTfloat_2_t = {"_p_VecMat__VecTfloat_2_t", "VecMat::Vec<float,2 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTfloat_3_t = {"_p_VecMat__VecTfloat_3_t", "VecMat::Vec<float,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTint_2_t = {"_p_VecMat__VecTint_2_t", "VecMat::Vec<int,2 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTint_3_t = {"_p_VecMat__VecTint_3_t", "VecMat::Vec<int,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTunsigned_int_2_t = {"_p_VecMat__VecTunsigned_int_2_t", "VecMat::Vec<unsigned int,2 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_VecMat__VecTunsigned_int_3_t = {"_p_VecMat__VecTunsigned_int_3_t", "VecMat::Vec<unsigned int,3 > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Vertex = {"_p_Vertex", "Vertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewEdge = {"_p_ViewEdge", "ViewEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewEdgeInternal__SVertexIterator = {"_p_ViewEdgeInternal__SVertexIterator", "ViewEdgeInternal::SVertexIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewEdgeInternal__ViewEdgeIterator = {"_p_ViewEdgeInternal__ViewEdgeIterator", "ViewEdgeInternal::ViewEdgeIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewMap = {"_p_ViewMap", "ViewMap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewShape = {"_p_ViewShape", "ViewShape *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertex = {"_p_ViewVertex", "ViewVertex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t = {"_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t", "ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits > *|ViewVertex::const_edge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t = {"_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t", "ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits > *|ViewVertex::edge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertexInternal__orientedViewEdgeIterator = {"_p_ViewVertexInternal__orientedViewEdgeIterator", "ViewVertexInternal::orientedViewEdgeIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator = {"_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator", "ViewVertexInternal::orientedViewEdgeIterator::edge_pointers_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator = {"_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator", "ViewVertexInternal::orientedViewEdgeIterator::edges_container::iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_const_edge_iterator = {"_p_const_edge_iterator", "const_edge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_const_fedge_iterator = {"_p_const_fedge_iterator", "const_fedge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_const_point_iterator = {"_p_const_point_iterator", "const_point_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_const_vertex_iterator = {"_p_const_vertex_iterator", "const_vertex_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_directedViewEdge = {"_p_directedViewEdge", "directedViewEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|VecMat::Vec3<double >::value_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_edge_iterator = {"_p_edge_iterator", "edge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_edge_pointers_container = {"_p_edge_pointers_container", "edge_pointers_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_edges_container = {"_p_edges_container", "edges_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_fedge_iterator = {"_p_fedge_iterator", "fedge_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_fedges_container = {"_p_fedges_container", "fedges_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_id_to_index_map = {"_p_id_to_index_map", "id_to_index_map *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_id_type = {"_p_id_type", "id_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *|VecMat::Vec3<int >::value_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ltstr = {"_p_ltstr", "ltstr *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_mapsMap = {"_p_mapsMap", "mapsMap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_occluder_container__const_iterator = {"_p_occluder_container__const_iterator", "occluder_container::const_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_point_iterator = {"_p_point_iterator", "point_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_point_type = {"_p_point_type", "point_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_setTVecMat__Vec3Tdouble_t_t = {"_p_setTVecMat__Vec3Tdouble_t_t", "set<VecMat::Vec3<double > > *|set<Geometry::Vec3r > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t = {"_p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t", "std::map<int,int > *|ViewMap::id_to_index_map *|std::map<int,int,std::less<int >,std::allocator<std::pair<int const,int > > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__pairTViewEdge_p_bool_t = {"_p_std__pairTViewEdge_p_bool_t", "std::pair<ViewEdge *,bool > *|::ViewVertex::directedViewEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t = {"_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t", "std::vector<FEdge * > *|std::vector<FEdge *,std::allocator<FEdge * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type = {"_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type", "std::allocator<FEdge * > *|std::vector<FEdge * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTMaterial_std__allocatorTMaterial_t_t = {"_p_std__vectorTMaterial_std__allocatorTMaterial_t_t", "std::vector<Material > *|std::vector<Material,std::allocator<Material > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t = {"_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t", "std::vector<SVertex * > *|ViewMap::svertices_container *|std::vector<SVertex *,std::allocator<SVertex * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type = {"_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type", "std::allocator<SVertex * > *|std::vector<SVertex * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t = {"_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t", "std::vector<StrokeShader * > *|std::vector<StrokeShader *,std::allocator<StrokeShader * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type = {"_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type", "std::allocator<StrokeShader * > *|std::vector<StrokeShader * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t = {"_p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t", "std::vector<TVertex * > *|std::vector<TVertex *,std::allocator<TVertex * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t = {"_p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t", "std::vector<VecMat::Vec2<double > > *|std::vector<Geometry::Vec2r > *|std::vector<VecMat::Vec2<double >,std::allocator<VecMat::Vec2<double > > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t = {"_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t", "std::vector<ViewEdge * > *|std::vector<ViewEdge *,std::allocator<ViewEdge * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type = {"_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type", "std::allocator<ViewEdge * > *|std::vector<ViewEdge * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t = {"_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t", "std::vector<ViewShape * > *|std::vector<ViewShape *,std::allocator<ViewShape * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type = {"_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type", "std::allocator<ViewShape * > *|std::vector<ViewShape * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t = {"_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t", "std::vector<ViewVertex * > *|std::vector<ViewVertex *,std::allocator<ViewVertex * > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type = {"_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type", "std::allocator<ViewVertex * > *|std::vector<ViewVertex * >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t = {"_p_std__vectorTint_std__allocatorTint_t_t", "std::vector<int > *|std::vector<int,std::allocator<int > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type = {"_p_std__vectorTint_std__allocatorTint_t_t__allocator_type", "std::allocator<int > *|std::vector<int >::allocator_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t = {"_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t", "std::vector<std::pair<ViewEdge *,bool > > *|std::vector<ViewVertex::directedViewEdge > *|std::vector<std::pair<ViewEdge *,bool >,std::allocator<std::pair<ViewEdge *,bool > > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t = {"_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t", "std::vector<unsigned int,std::allocator<unsigned int > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_svertices_container = {"_p_svertices_container", "svertices_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|VecMat::Vec3<unsigned int >::value_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|Nature::EdgeNature *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vertex_container = {"_p_vertex_container", "vertex_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vertex_iterator = {"_p_vertex_iterator", "vertex_iterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vertex_type = {"_p_vertex_type", "vertex_type *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_viewedge_container = {"_p_viewedge_container", "viewedge_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_viewedges_container = {"_p_viewedges_container", "viewedges_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_viewshapes_container = {"_p_viewshapes_container", "viewshapes_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_viewvertices_container = {"_p_viewvertices_container", "viewvertices_container *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type = {"_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type", "FEdge *|std::vector<FEdge * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type = {"_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type", "SVertex *|std::vector<SVertex * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type = {"_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type", "StrokeShader *|std::vector<StrokeShader * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type = {"_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type", "ViewEdge *|std::vector<ViewEdge * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type = {"_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type", "ViewShape *|std::vector<ViewShape * >::value_type", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type = {"_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type", "ViewVertex *|std::vector<ViewVertex * >::value_type", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_AdjacencyIterator,
+  &_swigt__p_BBoxTVecMat__Vec3Tdouble_t_t,
+  &_swigt__p_BinaryPredicate0D,
+  &_swigt__p_BinaryPredicate1D,
+  &_swigt__p_CalligraphicShader,
+  &_swigt__p_Canvas,
+  &_swigt__p_Chain,
+  &_swigt__p_ChainPredicateIterator,
+  &_swigt__p_ChainSilhouetteIterator,
+  &_swigt__p_ChainingIterator,
+  &_swigt__p_CurvatureInfo,
+  &_swigt__p_Curve,
+  &_swigt__p_CurveInternal__CurvePointIterator,
+  &_swigt__p_CurvePoint,
+  &_swigt__p_Curve__vertex_container__iterator,
+  &_swigt__p_FEdge,
+  &_swigt__p_FEdgeInternal__SVertexIterator,
+  &_swigt__p_FEdgeSharp,
+  &_swigt__p_FEdgeSmooth,
+  &_swigt__p_Functions0D__Curvature2DAngleF0D,
+  &_swigt__p_Functions0D__CurveNatureF0D,
+  &_swigt__p_Functions0D__DensityF0D,
+  &_swigt__p_Functions0D__GetCurvilinearAbscissaF0D,
+  &_swigt__p_Functions0D__GetOccludeeF0D,
+  &_swigt__p_Functions0D__GetOccludersF0D,
+  &_swigt__p_Functions0D__GetParameterF0D,
+  &_swigt__p_Functions0D__GetProjectedXF0D,
+  &_swigt__p_Functions0D__GetProjectedYF0D,
+  &_swigt__p_Functions0D__GetProjectedZF0D,
+  &_swigt__p_Functions0D__GetShapeF0D,
+  &_swigt__p_Functions0D__GetViewMapGradientNormF0D,
+  &_swigt__p_Functions0D__GetXF0D,
+  &_swigt__p_Functions0D__GetYF0D,
+  &_swigt__p_Functions0D__GetZF0D,
+  &_swigt__p_Functions0D__LocalAverageDepthF0D,
+  &_swigt__p_Functions0D__MaterialF0D,
+  &_swigt__p_Functions0D__Normal2DF0D,
+  &_swigt__p_Functions0D__QuantitativeInvisibilityF0D,
+  &_swigt__p_Functions0D__ReadCompleteViewMapPixelF0D,
+  &_swigt__p_Functions0D__ReadMapPixelF0D,
+  &_swigt__p_Functions0D__ReadSteerableViewMapPixelF0D,
+  &_swigt__p_Functions0D__ShapeIdF0D,
+  &_swigt__p_Functions0D__VertexOrientation2DF0D,
+  &_swigt__p_Functions0D__VertexOrientation3DF0D,
+  &_swigt__p_Functions0D__ZDiscontinuityF0D,
+  &_swigt__p_Functions1D__ChainingTimeStampF1D,
+  &_swigt__p_Functions1D__Curvature2DAngleF1D,
+  &_swigt__p_Functions1D__CurveNatureF1D,
+  &_swigt__p_Functions1D__DensityF1D,
+  &_swigt__p_Functions1D__GetCompleteViewMapDensityF1D,
+  &_swigt__p_Functions1D__GetDirectionalViewMapDensityF1D,
+  &_swigt__p_Functions1D__GetOccludeeF1D,
+  &_swigt__p_Functions1D__GetOccludersF1D,
+  &_swigt__p_Functions1D__GetProjectedXF1D,
+  &_swigt__p_Functions1D__GetProjectedYF1D,
+  &_swigt__p_Functions1D__GetProjectedZF1D,
+  &_swigt__p_Functions1D__GetShapeF1D,
+  &_swigt__p_Functions1D__GetSteerableViewMapDensityF1D,
+  &_swigt__p_Functions1D__GetViewMapGradientNormF1D,
+  &_swigt__p_Functions1D__GetXF1D,
+  &_swigt__p_Functions1D__GetYF1D,
+  &_swigt__p_Functions1D__GetZF1D,
+  &_swigt__p_Functions1D__IncrementChainingTimeStampF1D,
+  &_swigt__p_Functions1D__LocalAverageDepthF1D,
+  &_swigt__p_Functions1D__Normal2DF1D,
+  &_swigt__p_Functions1D__Orientation2DF1D,
+  &_swigt__p_Functions1D__Orientation3DF1D,
+  &_swigt__p_Functions1D__QuantitativeInvisibilityF1D,
+  &_swigt__p_Functions1D__TimeStampF1D,
+  &_swigt__p_Functions1D__ZDiscontinuityF1D,
+  &_swigt__p_GrayImage,
+  &_swigt__p_I1DContainer,
+  &_swigt__p_Id,
+  &_swigt__p_IntegrationType,
+  &_swigt__p_Interface0D,
+  &_swigt__p_Interface0DIterator,
+  &_swigt__p_Interface0DIteratorNested,
+  &_swigt__p_Interface1D,
+  &_swigt__p_Material,
+  &_swigt__p_MediumType,
+  &_swigt__p_Module,
+  &_swigt__p_Noise,
+  &_swigt__p_NonTVertex,
+  &_swigt__p_OmissionShader,
+  &_swigt__p_Omitter,
+  &_swigt__p_Operators,
+  &_swigt__p_Point,
+  &_swigt__p_Polygon3r,
+  &_swigt__p_Predicates0D__FalseUP0D,
+  &_swigt__p_Predicates0D__TrueUP0D,
+  &_swigt__p_Predicates1D__ContourUP1D,
+  &_swigt__p_Predicates1D__DensityLowerThanUP1D,
+  &_swigt__p_Predicates1D__EqualToChainingTimeStampUP1D,
+  &_swigt__p_Predicates1D__EqualToTimeStampUP1D,
+  &_swigt__p_Predicates1D__ExternalContourUP1D,
+  &_swigt__p_Predicates1D__FalseBP1D,
+  &_swigt__p_Predicates1D__FalseUP1D,
+  &_swigt__p_Predicates1D__Length2DBP1D,
+  &_swigt__p_Predicates1D__QuantitativeInvisibilityUP1D,
+  &_swigt__p_Predicates1D__SameShapeIdBP1D,
+  &_swigt__p_Predicates1D__ShapeUP1D,
+  &_swigt__p_Predicates1D__TrueBP1D,
+  &_swigt__p_Predicates1D__TrueUP1D,
+  &_swigt__p_Predicates1D__ViewMapGradientNormBP1D,
+  &_swigt__p_RGBImage,
+  &_swigt__p_ReturnedValueType,
+  &_swigt__p_SShape,
+  &_swigt__p_SVertex,
+  &_swigt__p_SVertex__fedges_container__iterator,
+  &_swigt__p_Smoother,
+  &_swigt__p_SmoothingShader,
+  &_swigt__p_SpatialNoiseShader,
+  &_swigt__p_SteerableViewMap,
+  &_swigt__p_Stroke,
+  &_swigt__p_StrokeAttribute,
+  &_swigt__p_StrokeInternal__StrokeVertexIterator,
+  &_swigt__p_StrokeLayer,
+  &_swigt__p_StrokeRenderer,
+  &_swigt__p_StrokeShader,
+  &_swigt__p_StrokeShaders__BSplineShader,
+  &_swigt__p_StrokeShaders__BackboneStretcherShader,
+  &_swigt__p_StrokeShaders__BezierCurveShader,
+  &_swigt__p_StrokeShaders__CalligraphicColorShader,
+  &_swigt__p_StrokeShaders__ColorNoiseShader,
+  &_swigt__p_StrokeShaders__ColorVariationPatternShader,
+  &_swigt__p_StrokeShaders__ConstantColorShader,
+  &_swigt__p_StrokeShaders__ConstantExternThicknessShader,
+  &_swigt__p_StrokeShaders__ConstantThicknessShader,
+  &_swigt__p_StrokeShaders__ConstrainedIncreasingThicknessShader,
+  &_swigt__p_StrokeShaders__ExternalContourStretcherShader,
+  &_swigt__p_StrokeShaders__GuidingLinesShader,
+  &_swigt__p_StrokeShaders__IncreasingColorShader,
+  &_swigt__p_StrokeShaders__IncreasingThicknessShader,
+  &_swigt__p_StrokeShaders__InflateShader,
+  &_swigt__p_StrokeShaders__LengthDependingThicknessShader,
+  &_swigt__p_StrokeShaders__MaterialColorShader,
+  &_swigt__p_StrokeShaders__PolygonalizationShader,
+  &_swigt__p_StrokeShaders__SamplingShader,
+  &_swigt__p_StrokeShaders__StrokeTextureShader,
+  &_swigt__p_StrokeShaders__TextureAssignerShader,
+  &_swigt__p_StrokeShaders__ThicknessNoiseShader,
+  &_swigt__p_StrokeShaders__ThicknessVariationPatternShader,
+  &_swigt__p_StrokeShaders__TipRemoverShader,
+  &_swigt__p_StrokeShaders__fstreamShader,
+  &_swigt__p_StrokeShaders__streamShader,
+  &_swigt__p_StrokeVertex,
+  &_swigt__p_Stroke__vertex_container__iterator,
+  &_swigt__p_Stroke__viewedge_container__const_iterator,
+  &_swigt__p_Stroke__viewedge_container__iterator,
+  &_swigt__p_StrokesContainer,
+  &_swigt__p_StyleModule,
+  &_swigt__p_TVertex,
+  &_swigt__p_UnaryFunction0DTId_t,
+  &_swigt__p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t,
+  &_swigt__p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t,
+  &_swigt__p_UnaryFunction0DTViewShape_p_t,
+  &_swigt__p_UnaryFunction0DTdouble_t,
+  &_swigt__p_UnaryFunction0DTfloat_t,
+  &_swigt__p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t,
+  &_swigt__p_UnaryFunction0DTunsigned_int_t,
+  &_swigt__p_UnaryFunction0DTvoid_t,
+  &_swigt__p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t,
+  &_swigt__p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t,
+  &_swigt__p_UnaryFunction1DTdouble_t,
+  &_swigt__p_UnaryFunction1DTfloat_t,
+  &_swigt__p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t,
+  &_swigt__p_UnaryFunction1DTunsigned_int_t,
+  &_swigt__p_UnaryFunction1DTvoid_t,
+  &_swigt__p_UnaryPredicate0D,
+  &_swigt__p_UnaryPredicate1D,
+  &_swigt__p_VecMat__HVec3Tdouble_t,
+  &_swigt__p_VecMat__HVec3Tfloat_t,
+  &_swigt__p_VecMat__HVec3Tint_t,
+  &_swigt__p_VecMat__HVec3Tunsigned_int_t,
+  &_swigt__p_VecMat__SquareMatrixTdouble_2_t,
+  &_swigt__p_VecMat__SquareMatrixTdouble_3_t,
+  &_swigt__p_VecMat__SquareMatrixTdouble_4_t,
+  &_swigt__p_VecMat__SquareMatrixTfloat_2_t,
+  &_swigt__p_VecMat__SquareMatrixTfloat_3_t,
+  &_swigt__p_VecMat__SquareMatrixTfloat_4_t,
+  &_swigt__p_VecMat__SquareMatrixTint_2_t,
+  &_swigt__p_VecMat__SquareMatrixTint_3_t,
+  &_swigt__p_VecMat__SquareMatrixTint_4_t,
+  &_swigt__p_VecMat__SquareMatrixTunsigned_int_2_t,
+  &_swigt__p_VecMat__SquareMatrixTunsigned_int_3_t,
+  &_swigt__p_VecMat__SquareMatrixTunsigned_int_4_t,
+  &_swigt__p_VecMat__Vec2Tdouble_t,
+  &_swigt__p_VecMat__Vec2Tfloat_t,
+  &_swigt__p_VecMat__Vec2Tint_t,
+  &_swigt__p_VecMat__Vec2Tunsigned_int_t,
+  &_swigt__p_VecMat__Vec3Tdouble_t,
+  &_swigt__p_VecMat__Vec3Tfloat_t,
+  &_swigt__p_VecMat__Vec3Tint_t,
+  &_swigt__p_VecMat__Vec3Tunsigned_int_t,
+  &_swigt__p_VecMat__VecTdouble_2_t,
+  &_swigt__p_VecMat__VecTdouble_3_t,
+  &_swigt__p_VecMat__VecTfloat_2_t,
+  &_swigt__p_VecMat__VecTfloat_3_t,
+  &_swigt__p_VecMat__VecTint_2_t,
+  &_swigt__p_VecMat__VecTint_3_t,
+  &_swigt__p_VecMat__VecTunsigned_int_2_t,
+  &_swigt__p_VecMat__VecTunsigned_int_3_t,
+  &_swigt__p_Vertex,
+  &_swigt__p_ViewEdge,
+  &_swigt__p_ViewEdgeInternal__SVertexIterator,
+  &_swigt__p_ViewEdgeInternal__ViewEdgeIterator,
+  &_swigt__p_ViewMap,
+  &_swigt__p_ViewShape,
+  &_swigt__p_ViewVertex,
+  &_swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t,
+  &_swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t,
+  &_swigt__p_ViewVertexInternal__orientedViewEdgeIterator,
+  &_swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator,
+  &_swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator,
+  &_swigt__p_allocator_type,
+  &_swigt__p_char,
+  &_swigt__p_const_edge_iterator,
+  &_swigt__p_const_fedge_iterator,
+  &_swigt__p_const_point_iterator,
+  &_swigt__p_const_reference,
+  &_swigt__p_const_vertex_iterator,
+  &_swigt__p_difference_type,
+  &_swigt__p_directedViewEdge,
+  &_swigt__p_double,
+  &_swigt__p_edge_iterator,
+  &_swigt__p_edge_pointers_container,
+  &_swigt__p_edges_container,
+  &_swigt__p_fedge_iterator,
+  &_swigt__p_fedges_container,
+  &_swigt__p_float,
+  &_swigt__p_id_to_index_map,
+  &_swigt__p_id_type,
+  &_swigt__p_int,
+  &_swigt__p_ltstr,
+  &_swigt__p_mapsMap,
+  &_swigt__p_occluder_container__const_iterator,
+  &_swigt__p_p_PyObject,
+  &_swigt__p_point_iterator,
+  &_swigt__p_point_type,
+  &_swigt__p_reference,
+  &_swigt__p_setTVecMat__Vec3Tdouble_t_t,
+  &_swigt__p_size_type,
+  &_swigt__p_std__invalid_argument,
+  &_swigt__p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t,
+  &_swigt__p_std__pairTViewEdge_p_bool_t,
+  &_swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,
+  &_swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTMaterial_std__allocatorTMaterial_t_t,
+  &_swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t,
+  &_swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t,
+  &_swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t,
+  &_swigt__p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t,
+  &_swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t,
+  &_swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t,
+  &_swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t,
+  &_swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type,
+  &_swigt__p_std__vectorTint_std__allocatorTint_t_t,
+  &_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
+  &_swigt__p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t,
+  &_swigt__p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t,
+  &_swigt__p_svertices_container,
+  &_swigt__p_swig__PySwigIterator,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_short,
+  &_swigt__p_value_type,
+  &_swigt__p_vertex_container,
+  &_swigt__p_vertex_iterator,
+  &_swigt__p_vertex_type,
+  &_swigt__p_viewedge_container,
+  &_swigt__p_viewedges_container,
+  &_swigt__p_viewshapes_container,
+  &_swigt__p_viewvertices_container,
+  &_swigt__p_void,
+  &_swigt__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type,
+  &_swigt__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type,
+  &_swigt__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type,
+  &_swigt__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type,
+  &_swigt__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type,
+  &_swigt__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type,
+};
+
+static swig_cast_info _swigc__p_AdjacencyIterator[] = {  {&_swigt__p_AdjacencyIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_BBoxTVecMat__Vec3Tdouble_t_t[] = {  {&_swigt__p_BBoxTVecMat__Vec3Tdouble_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_BinaryPredicate0D[] = {  {&_swigt__p_BinaryPredicate0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_BinaryPredicate1D[] = {  {&_swigt__p_Predicates1D__Length2DBP1D, _p_Predicates1D__Length2DBP1DTo_p_BinaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__FalseBP1D, _p_Predicates1D__FalseBP1DTo_p_BinaryPredicate1D, 0, 0},  {&_swigt__p_BinaryPredicate1D, 0, 0, 0},  {&_swigt__p_Predicates1D__ViewMapGradientNormBP1D, _p_Predicates1D__ViewMapGradientNormBP1DTo_p_BinaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__TrueBP1D, _p_Predicates1D__TrueBP1DTo_p_BinaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__SameShapeIdBP1D, _p_Predicates1D__SameShapeIdBP1DTo_p_BinaryPredicate1D, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CalligraphicShader[] = {  {&_swigt__p_CalligraphicShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Canvas[] = {  {&_swigt__p_Canvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Chain[] = {  {&_swigt__p_Chain, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ChainPredicateIterator[] = {  {&_swigt__p_ChainPredicateIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ChainSilhouetteIterator[] = {  {&_swigt__p_ChainSilhouetteIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ChainingIterator[] = {  {&_swigt__p_ChainingIterator, 0, 0, 0},  {&_swigt__p_ChainSilhouetteIterator, _p_ChainSilhouetteIteratorTo_p_ChainingIterator, 0, 0},  {&_swigt__p_ChainPredicateIterator, _p_ChainPredicateIteratorTo_p_ChainingIterator, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CurvatureInfo[] = {  {&_swigt__p_CurvatureInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Curve[] = {  {&_swigt__p_Curve, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CurveInternal__CurvePointIterator[] = {  {&_swigt__p_CurveInternal__CurvePointIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CurvePoint[] = {  {&_swigt__p_StrokeVertex, _p_StrokeVertexTo_p_CurvePoint, 0, 0},  {&_swigt__p_CurvePoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Curve__vertex_container__iterator[] = {  {&_swigt__p_Curve__vertex_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FEdge[] = {  {&_swigt__p_FEdge, 0, 0, 0},  {&_swigt__p_FEdgeSharp, _p_FEdgeSharpTo_p_FEdge, 0, 0},  {&_swigt__p_FEdgeSmooth, _p_FEdgeSmoothTo_p_FEdge, 0, 0},  {&_swigt__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FEdgeInternal__SVertexIterator[] = {  {&_swigt__p_FEdgeInternal__SVertexIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FEdgeSharp[] = {  {&_swigt__p_FEdgeSharp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FEdgeSmooth[] = {  {&_swigt__p_FEdgeSmooth, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__Curvature2DAngleF0D[] = {  {&_swigt__p_Functions0D__Curvature2DAngleF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__CurveNatureF0D[] = {  {&_swigt__p_Functions0D__CurveNatureF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__DensityF0D[] = {  {&_swigt__p_Functions0D__DensityF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetCurvilinearAbscissaF0D[] = {  {&_swigt__p_Functions0D__GetCurvilinearAbscissaF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetOccludeeF0D[] = {  {&_swigt__p_Functions0D__GetOccludeeF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetOccludersF0D[] = {  {&_swigt__p_Functions0D__GetOccludersF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetParameterF0D[] = {  {&_swigt__p_Functions0D__GetParameterF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetProjectedXF0D[] = {  {&_swigt__p_Functions0D__GetProjectedXF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetProjectedYF0D[] = {  {&_swigt__p_Functions0D__GetProjectedYF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetProjectedZF0D[] = {  {&_swigt__p_Functions0D__GetProjectedZF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetShapeF0D[] = {  {&_swigt__p_Functions0D__GetShapeF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetViewMapGradientNormF0D[] = {  {&_swigt__p_Functions0D__GetViewMapGradientNormF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetXF0D[] = {  {&_swigt__p_Functions0D__GetXF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetYF0D[] = {  {&_swigt__p_Functions0D__GetYF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__GetZF0D[] = {  {&_swigt__p_Functions0D__GetZF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__LocalAverageDepthF0D[] = {  {&_swigt__p_Functions0D__LocalAverageDepthF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__MaterialF0D[] = {  {&_swigt__p_Functions0D__MaterialF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__Normal2DF0D[] = {  {&_swigt__p_Functions0D__Normal2DF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__QuantitativeInvisibilityF0D[] = {  {&_swigt__p_Functions0D__QuantitativeInvisibilityF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__ReadCompleteViewMapPixelF0D[] = {  {&_swigt__p_Functions0D__ReadCompleteViewMapPixelF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__ReadMapPixelF0D[] = {  {&_swigt__p_Functions0D__ReadMapPixelF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__ReadSteerableViewMapPixelF0D[] = {  {&_swigt__p_Functions0D__ReadSteerableViewMapPixelF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__ShapeIdF0D[] = {  {&_swigt__p_Functions0D__ShapeIdF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__VertexOrientation2DF0D[] = {  {&_swigt__p_Functions0D__VertexOrientation2DF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__VertexOrientation3DF0D[] = {  {&_swigt__p_Functions0D__VertexOrientation3DF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions0D__ZDiscontinuityF0D[] = {  {&_swigt__p_Functions0D__ZDiscontinuityF0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__ChainingTimeStampF1D[] = {  {&_swigt__p_Functions1D__ChainingTimeStampF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__Curvature2DAngleF1D[] = {  {&_swigt__p_Functions1D__Curvature2DAngleF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__CurveNatureF1D[] = {  {&_swigt__p_Functions1D__CurveNatureF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__DensityF1D[] = {  {&_swigt__p_Functions1D__DensityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetCompleteViewMapDensityF1D[] = {  {&_swigt__p_Functions1D__GetCompleteViewMapDensityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetDirectionalViewMapDensityF1D[] = {  {&_swigt__p_Functions1D__GetDirectionalViewMapDensityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetOccludeeF1D[] = {  {&_swigt__p_Functions1D__GetOccludeeF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetOccludersF1D[] = {  {&_swigt__p_Functions1D__GetOccludersF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetProjectedXF1D[] = {  {&_swigt__p_Functions1D__GetProjectedXF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetProjectedYF1D[] = {  {&_swigt__p_Functions1D__GetProjectedYF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetProjectedZF1D[] = {  {&_swigt__p_Functions1D__GetProjectedZF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetShapeF1D[] = {  {&_swigt__p_Functions1D__GetShapeF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetSteerableViewMapDensityF1D[] = {  {&_swigt__p_Functions1D__GetSteerableViewMapDensityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetViewMapGradientNormF1D[] = {  {&_swigt__p_Functions1D__GetViewMapGradientNormF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetXF1D[] = {  {&_swigt__p_Functions1D__GetXF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetYF1D[] = {  {&_swigt__p_Functions1D__GetYF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__GetZF1D[] = {  {&_swigt__p_Functions1D__GetZF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__IncrementChainingTimeStampF1D[] = {  {&_swigt__p_Functions1D__IncrementChainingTimeStampF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__LocalAverageDepthF1D[] = {  {&_swigt__p_Functions1D__LocalAverageDepthF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__Normal2DF1D[] = {  {&_swigt__p_Functions1D__Normal2DF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__Orientation2DF1D[] = {  {&_swigt__p_Functions1D__Orientation2DF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__Orientation3DF1D[] = {  {&_swigt__p_Functions1D__Orientation3DF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__QuantitativeInvisibilityF1D[] = {  {&_swigt__p_Functions1D__QuantitativeInvisibilityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__TimeStampF1D[] = {  {&_swigt__p_Functions1D__TimeStampF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Functions1D__ZDiscontinuityF1D[] = {  {&_swigt__p_Functions1D__ZDiscontinuityF1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_GrayImage[] = {  {&_swigt__p_GrayImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_I1DContainer[] = {  {&_swigt__p_I1DContainer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Id[] = {  {&_swigt__p_Id, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_IntegrationType[] = {  {&_swigt__p_IntegrationType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Interface0D[] = {  {&_swigt__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, _p_SVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_TVertex, _p_TVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_NonTVertex, _p_NonTVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_Interface0D, 0, 0, 0},  {&_swigt__p_SVertex, _p_SVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_ViewVertex, _p_ViewVertexTo_p_Interface0D, 0, 0},  {&_swigt__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, _p_ViewVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_StrokeVertex, _p_StrokeVertexTo_p_Interface0D, 0, 0},  {&_swigt__p_CurvePoint, _p_CurvePointTo_p_Interface0D, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Interface0DIterator[] = {  {&_swigt__p_Interface0DIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Interface0DIteratorNested[] = {  {&_swigt__p_Interface0DIteratorNested, 0, 0, 0},  {&_swigt__p_FEdgeInternal__SVertexIterator, _p_FEdgeInternal__SVertexIteratorTo_p_Interface0DIteratorNested, 0, 0},  {&_swigt__p_ViewEdgeInternal__SVertexIterator, _p_ViewEdgeInternal__SVertexIteratorTo_p_Interface0DIteratorNested, 0, 0},  {&_swigt__p_CurveInternal__CurvePointIterator, _p_CurveInternal__CurvePointIteratorTo_p_Interface0DIteratorNested, 0, 0},  {&_swigt__p_StrokeInternal__StrokeVertexIterator, _p_StrokeInternal__StrokeVertexIteratorTo_p_Interface0DIteratorNested, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Interface1D[] = {  {&_swigt__p_Interface1D, 0, 0, 0},  {&_swigt__p_ViewEdge, _p_ViewEdgeTo_p_Interface1D, 0, 0},  {&_swigt__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_Curve, _p_CurveTo_p_Interface1D, 0, 0},  {&_swigt__p_Stroke, _p_StrokeTo_p_Interface1D, 0, 0},  {&_swigt__p_FEdgeSharp, _p_FEdgeSharpTo_p_Interface1D, 0, 0},  {&_swigt__p_FEdgeSmooth, _p_FEdgeSmoothTo_p_Interface1D, 0, 0},  {&_swigt__p_FEdge, _p_FEdgeTo_p_Interface1D, 0, 0},  {&_swigt__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Material[] = {  {&_swigt__p_Material, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_MediumType[] = {  {&_swigt__p_MediumType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Module[] = {  {&_swigt__p_Module, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Noise[] = {  {&_swigt__p_Noise, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_NonTVertex[] = {  {&_swigt__p_NonTVertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_OmissionShader[] = {  {&_swigt__p_OmissionShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Omitter[] = {  {&_swigt__p_Omitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Operators[] = {  {&_swigt__p_Operators, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Point[] = {  {&_swigt__p_Point, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Polygon3r[] = {  {&_swigt__p_Polygon3r, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates0D__FalseUP0D[] = {  {&_swigt__p_Predicates0D__FalseUP0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates0D__TrueUP0D[] = {  {&_swigt__p_Predicates0D__TrueUP0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__ContourUP1D[] = {  {&_swigt__p_Predicates1D__ContourUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__DensityLowerThanUP1D[] = {  {&_swigt__p_Predicates1D__DensityLowerThanUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__EqualToChainingTimeStampUP1D[] = {  {&_swigt__p_Predicates1D__EqualToChainingTimeStampUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__EqualToTimeStampUP1D[] = {  {&_swigt__p_Predicates1D__EqualToTimeStampUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__ExternalContourUP1D[] = {  {&_swigt__p_Predicates1D__ExternalContourUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__FalseBP1D[] = {  {&_swigt__p_Predicates1D__FalseBP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__FalseUP1D[] = {  {&_swigt__p_Predicates1D__FalseUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__Length2DBP1D[] = {  {&_swigt__p_Predicates1D__Length2DBP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__QuantitativeInvisibilityUP1D[] = {  {&_swigt__p_Predicates1D__QuantitativeInvisibilityUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__SameShapeIdBP1D[] = {  {&_swigt__p_Predicates1D__SameShapeIdBP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__ShapeUP1D[] = {  {&_swigt__p_Predicates1D__ShapeUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__TrueBP1D[] = {  {&_swigt__p_Predicates1D__TrueBP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__TrueUP1D[] = {  {&_swigt__p_Predicates1D__TrueUP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Predicates1D__ViewMapGradientNormBP1D[] = {  {&_swigt__p_Predicates1D__ViewMapGradientNormBP1D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_RGBImage[] = {  {&_swigt__p_RGBImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ReturnedValueType[] = {  {&_swigt__p_ReturnedValueType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SShape[] = {  {&_swigt__p_SShape, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SVertex[] = {  {&_swigt__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_SVertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SVertex__fedges_container__iterator[] = {  {&_swigt__p_SVertex__fedges_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Smoother[] = {  {&_swigt__p_Smoother, 0, 0, 0},  {&_swigt__p_Omitter, _p_OmitterTo_p_Smoother, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SmoothingShader[] = {  {&_swigt__p_SmoothingShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SpatialNoiseShader[] = {  {&_swigt__p_SpatialNoiseShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SteerableViewMap[] = {  {&_swigt__p_SteerableViewMap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Stroke[] = {  {&_swigt__p_Stroke, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeAttribute[] = {  {&_swigt__p_StrokeAttribute, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeInternal__StrokeVertexIterator[] = {  {&_swigt__p_StrokeInternal__StrokeVertexIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeLayer[] = {  {&_swigt__p_StrokeLayer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeRenderer[] = {  {&_swigt__p_StrokeRenderer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShader[] = {  {&_swigt__p_StrokeShaders__ConstrainedIncreasingThicknessShader, _p_StrokeShaders__ConstrainedIncreasingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_StrokeShaders__ColorNoiseShader, _p_StrokeShaders__ColorNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ThicknessNoiseShader, _p_StrokeShaders__ThicknessNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__LengthDependingThicknessShader, _p_StrokeShaders__LengthDependingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__IncreasingThicknessShader, _p_StrokeShaders__IncreasingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantExternThicknessShader, _p_StrokeShaders__ConstantExternThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantThicknessShader, _p_StrokeShaders__ConstantThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__StrokeTextureShader, _p_StrokeShaders__StrokeTextureShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__SamplingShader, _p_StrokeShaders__SamplingShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BSplineShader, _p_StrokeShaders__BSplineShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BezierCurveShader, _p_StrokeShaders__BezierCurveShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__InflateShader, _p_StrokeShaders__InflateShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShader, 0, 0, 0},  {&_swigt__p_StrokeShaders__GuidingLinesShader, _p_StrokeShaders__GuidingLinesShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__streamShader, _p_StrokeShaders__streamShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__fstreamShader, _p_StrokeShaders__fstreamShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_CalligraphicShader, _p_CalligraphicShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_SpatialNoiseShader, _p_SpatialNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_SmoothingShader, _p_SmoothingShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__TextureAssignerShader, _p_StrokeShaders__TextureAssignerShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__CalligraphicColorShader, _p_StrokeShaders__CalligraphicColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__MaterialColorShader, _p_StrokeShaders__MaterialColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ColorVariationPatternShader, _p_StrokeShaders__ColorVariationPatternShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__IncreasingColorShader, _p_StrokeShaders__IncreasingColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantColorShader, _p_StrokeShaders__ConstantColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ThicknessVariationPatternShader, _p_StrokeShaders__ThicknessVariationPatternShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BackboneStretcherShader, _p_StrokeShaders__BackboneStretcherShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ExternalContourStretcherShader, _p_StrokeShaders__ExternalContourStretcherShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__PolygonalizationShader, _p_StrokeShaders__PolygonalizationShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__TipRemoverShader, _p_StrokeShaders__TipRemoverShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_OmissionShader, _p_OmissionShaderTo_p_StrokeShader, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__BSplineShader[] = {  {&_swigt__p_StrokeShaders__BSplineShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__BackboneStretcherShader[] = {  {&_swigt__p_StrokeShaders__BackboneStretcherShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__BezierCurveShader[] = {  {&_swigt__p_StrokeShaders__BezierCurveShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__CalligraphicColorShader[] = {  {&_swigt__p_StrokeShaders__CalligraphicColorShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ColorNoiseShader[] = {  {&_swigt__p_StrokeShaders__ColorNoiseShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ColorVariationPatternShader[] = {  {&_swigt__p_StrokeShaders__ColorVariationPatternShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ConstantColorShader[] = {  {&_swigt__p_StrokeShaders__ConstantColorShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ConstantExternThicknessShader[] = {  {&_swigt__p_StrokeShaders__ConstantExternThicknessShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ConstantThicknessShader[] = {  {&_swigt__p_StrokeShaders__ConstantThicknessShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ConstrainedIncreasingThicknessShader[] = {  {&_swigt__p_StrokeShaders__ConstrainedIncreasingThicknessShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ExternalContourStretcherShader[] = {  {&_swigt__p_StrokeShaders__ExternalContourStretcherShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__GuidingLinesShader[] = {  {&_swigt__p_StrokeShaders__GuidingLinesShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__IncreasingColorShader[] = {  {&_swigt__p_StrokeShaders__IncreasingColorShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__IncreasingThicknessShader[] = {  {&_swigt__p_StrokeShaders__IncreasingThicknessShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__InflateShader[] = {  {&_swigt__p_StrokeShaders__InflateShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__LengthDependingThicknessShader[] = {  {&_swigt__p_StrokeShaders__LengthDependingThicknessShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__MaterialColorShader[] = {  {&_swigt__p_StrokeShaders__MaterialColorShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__PolygonalizationShader[] = {  {&_swigt__p_StrokeShaders__PolygonalizationShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__SamplingShader[] = {  {&_swigt__p_StrokeShaders__SamplingShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__StrokeTextureShader[] = {  {&_swigt__p_StrokeShaders__StrokeTextureShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__TextureAssignerShader[] = {  {&_swigt__p_StrokeShaders__TextureAssignerShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ThicknessNoiseShader[] = {  {&_swigt__p_StrokeShaders__ThicknessNoiseShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__ThicknessVariationPatternShader[] = {  {&_swigt__p_StrokeShaders__ThicknessVariationPatternShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__TipRemoverShader[] = {  {&_swigt__p_StrokeShaders__TipRemoverShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__fstreamShader[] = {  {&_swigt__p_StrokeShaders__fstreamShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeShaders__streamShader[] = {  {&_swigt__p_StrokeShaders__streamShader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokeVertex[] = {  {&_swigt__p_StrokeVertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Stroke__vertex_container__iterator[] = {  {&_swigt__p_Stroke__vertex_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Stroke__viewedge_container__const_iterator[] = {  {&_swigt__p_Stroke__viewedge_container__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Stroke__viewedge_container__iterator[] = {  {&_swigt__p_Stroke__viewedge_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StrokesContainer[] = {  {&_swigt__p_StrokesContainer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_StyleModule[] = {  {&_swigt__p_StyleModule, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TVertex[] = {  {&_swigt__p_TVertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTId_t[] = {  {&_swigt__p_UnaryFunction0DTId_t, 0, 0, 0},  {&_swigt__p_Functions0D__ShapeIdF0D, _p_Functions0D__ShapeIdF0DTo_p_UnaryFunction0DTId_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t[] = {  {&_swigt__p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0, 0, 0},  {&_swigt__p_Functions0D__VertexOrientation2DF0D, _p_Functions0D__VertexOrientation2DF0DTo_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0, 0},  {&_swigt__p_Functions0D__Normal2DF0D, _p_Functions0D__Normal2DF0DTo_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t[] = {  {&_swigt__p_Functions0D__VertexOrientation3DF0D, _p_Functions0D__VertexOrientation3DF0DTo_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, 0, 0},  {&_swigt__p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTViewShape_p_t[] = {  {&_swigt__p_Functions0D__GetShapeF0D, _p_Functions0D__GetShapeF0DTo_p_UnaryFunction0DTViewShape_p_t, 0, 0},  {&_swigt__p_Functions0D__GetOccludeeF0D, _p_Functions0D__GetOccludeeF0DTo_p_UnaryFunction0DTViewShape_p_t, 0, 0},  {&_swigt__p_UnaryFunction0DTViewShape_p_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTdouble_t[] = {  {&_swigt__p_UnaryFunction0DTdouble_t, 0, 0, 0},  {&_swigt__p_Functions0D__ZDiscontinuityF0D, _p_Functions0D__ZDiscontinuityF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__DensityF0D, _p_Functions0D__DensityF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetXF0D, _p_Functions0D__GetXF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetProjectedXF0D, _p_Functions0D__GetProjectedXF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__Curvature2DAngleF0D, _p_Functions0D__Curvature2DAngleF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetYF0D, _p_Functions0D__GetYF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetProjectedYF0D, _p_Functions0D__GetProjectedYF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetZF0D, _p_Functions0D__GetZF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__GetProjectedZF0D, _p_Functions0D__GetProjectedZF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},  {&_swigt__p_Functions0D__LocalAverageDepthF0D, _p_Functions0D__LocalAverageDepthF0DTo_p_UnaryFunction0DTdouble_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTfloat_t[] = {  {&_swigt__p_Functions0D__GetCurvilinearAbscissaF0D, _p_Functions0D__GetCurvilinearAbscissaF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},  {&_swigt__p_Functions0D__ReadMapPixelF0D, _p_Functions0D__ReadMapPixelF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},  {&_swigt__p_Functions0D__ReadSteerableViewMapPixelF0D, _p_Functions0D__ReadSteerableViewMapPixelF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},  {&_swigt__p_Functions0D__ReadCompleteViewMapPixelF0D, _p_Functions0D__ReadCompleteViewMapPixelF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},  {&_swigt__p_Functions0D__GetViewMapGradientNormF0D, _p_Functions0D__GetViewMapGradientNormF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},  {&_swigt__p_UnaryFunction0DTfloat_t, 0, 0, 0},  {&_swigt__p_Functions0D__GetParameterF0D, _p_Functions0D__GetParameterF0DTo_p_UnaryFunction0DTfloat_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t[] = {  {&_swigt__p_Functions0D__GetOccludersF0D, _p_Functions0D__GetOccludersF0DTo_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0},  {&_swigt__p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTunsigned_int_t[] = {  {&_swigt__p_Functions0D__QuantitativeInvisibilityF0D, _p_Functions0D__QuantitativeInvisibilityF0DTo_p_UnaryFunction0DTunsigned_int_t, 0, 0},  {&_swigt__p_UnaryFunction0DTunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction0DTvoid_t[] = {  {&_swigt__p_UnaryFunction0DTvoid_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t[] = {  {&_swigt__p_Functions1D__Orientation2DF1D, _p_Functions1D__Orientation2DF1DTo_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0, 0},  {&_swigt__p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0, 0, 0},  {&_swigt__p_Functions1D__Normal2DF1D, _p_Functions1D__Normal2DF1DTo_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t[] = {  {&_swigt__p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0, 0, 0},  {&_swigt__p_Functions1D__Orientation3DF1D, _p_Functions1D__Orientation3DF1DTo_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTdouble_t[] = {  {&_swigt__p_Functions1D__GetSteerableViewMapDensityF1D, _p_Functions1D__GetSteerableViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetDirectionalViewMapDensityF1D, _p_Functions1D__GetDirectionalViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetCompleteViewMapDensityF1D, _p_Functions1D__GetCompleteViewMapDensityF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__DensityF1D, _p_Functions1D__DensityF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__ZDiscontinuityF1D, _p_Functions1D__ZDiscontinuityF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetXF1D, _p_Functions1D__GetXF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetZF1D, _p_Functions1D__GetZF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetViewMapGradientNormF1D, _p_Functions1D__GetViewMapGradientNormF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetProjectedYF1D, _p_Functions1D__GetProjectedYF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_UnaryFunction1DTdouble_t, 0, 0, 0},  {&_swigt__p_Functions1D__Curvature2DAngleF1D, _p_Functions1D__Curvature2DAngleF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetYF1D, _p_Functions1D__GetYF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetProjectedXF1D, _p_Functions1D__GetProjectedXF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__LocalAverageDepthF1D, _p_Functions1D__LocalAverageDepthF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},  {&_swigt__p_Functions1D__GetProjectedZF1D, _p_Functions1D__GetProjectedZF1DTo_p_UnaryFunction1DTdouble_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTfloat_t[] = {  {&_swigt__p_UnaryFunction1DTfloat_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t[] = {  {&_swigt__p_Functions1D__GetOccludeeF1D, _p_Functions1D__GetOccludeeF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0},  {&_swigt__p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0, 0},  {&_swigt__p_Functions1D__GetShapeF1D, _p_Functions1D__GetShapeF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0},  {&_swigt__p_Functions1D__GetOccludersF1D, _p_Functions1D__GetOccludersF1DTo_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTunsigned_int_t[] = {  {&_swigt__p_Functions1D__QuantitativeInvisibilityF1D, _p_Functions1D__QuantitativeInvisibilityF1DTo_p_UnaryFunction1DTunsigned_int_t, 0, 0},  {&_swigt__p_UnaryFunction1DTunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryFunction1DTvoid_t[] = {  {&_swigt__p_UnaryFunction1DTvoid_t, 0, 0, 0},  {&_swigt__p_Functions1D__TimeStampF1D, _p_Functions1D__TimeStampF1DTo_p_UnaryFunction1DTvoid_t, 0, 0},  {&_swigt__p_Functions1D__IncrementChainingTimeStampF1D, _p_Functions1D__IncrementChainingTimeStampF1DTo_p_UnaryFunction1DTvoid_t, 0, 0},  {&_swigt__p_Functions1D__ChainingTimeStampF1D, _p_Functions1D__ChainingTimeStampF1DTo_p_UnaryFunction1DTvoid_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryPredicate0D[] = {  {&_swigt__p_Predicates0D__TrueUP0D, _p_Predicates0D__TrueUP0DTo_p_UnaryPredicate0D, 0, 0},  {&_swigt__p_Predicates0D__FalseUP0D, _p_Predicates0D__FalseUP0DTo_p_UnaryPredicate0D, 0, 0},  {&_swigt__p_UnaryPredicate0D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UnaryPredicate1D[] = {  {&_swigt__p_Predicates1D__FalseUP1D, _p_Predicates1D__FalseUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__ShapeUP1D, _p_Predicates1D__ShapeUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__DensityLowerThanUP1D, _p_Predicates1D__DensityLowerThanUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_UnaryPredicate1D, 0, 0, 0},  {&_swigt__p_Predicates1D__EqualToTimeStampUP1D, _p_Predicates1D__EqualToTimeStampUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__EqualToChainingTimeStampUP1D, _p_Predicates1D__EqualToChainingTimeStampUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__TrueUP1D, _p_Predicates1D__TrueUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__QuantitativeInvisibilityUP1D, _p_Predicates1D__QuantitativeInvisibilityUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__ContourUP1D, _p_Predicates1D__ContourUP1DTo_p_UnaryPredicate1D, 0, 0},  {&_swigt__p_Predicates1D__ExternalContourUP1D, _p_Predicates1D__ExternalContourUP1DTo_p_UnaryPredicate1D, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__HVec3Tdouble_t[] = {  {&_swigt__p_VecMat__HVec3Tdouble_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__HVec3Tfloat_t[] = {  {&_swigt__p_VecMat__HVec3Tfloat_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__HVec3Tint_t[] = {  {&_swigt__p_VecMat__HVec3Tint_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__HVec3Tunsigned_int_t[] = {  {&_swigt__p_VecMat__HVec3Tunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTdouble_2_t[] = {  {&_swigt__p_VecMat__SquareMatrixTdouble_2_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTdouble_3_t[] = {  {&_swigt__p_VecMat__SquareMatrixTdouble_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTdouble_4_t[] = {  {&_swigt__p_VecMat__SquareMatrixTdouble_4_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTfloat_2_t[] = {  {&_swigt__p_VecMat__SquareMatrixTfloat_2_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTfloat_3_t[] = {  {&_swigt__p_VecMat__SquareMatrixTfloat_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTfloat_4_t[] = {  {&_swigt__p_VecMat__SquareMatrixTfloat_4_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTint_2_t[] = {  {&_swigt__p_VecMat__SquareMatrixTint_2_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTint_3_t[] = {  {&_swigt__p_VecMat__SquareMatrixTint_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTint_4_t[] = {  {&_swigt__p_VecMat__SquareMatrixTint_4_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTunsigned_int_2_t[] = {  {&_swigt__p_VecMat__SquareMatrixTunsigned_int_2_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTunsigned_int_3_t[] = {  {&_swigt__p_VecMat__SquareMatrixTunsigned_int_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__SquareMatrixTunsigned_int_4_t[] = {  {&_swigt__p_VecMat__SquareMatrixTunsigned_int_4_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec2Tdouble_t[] = {  {&_swigt__p_VecMat__Vec2Tdouble_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec2Tfloat_t[] = {  {&_swigt__p_VecMat__Vec2Tfloat_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec2Tint_t[] = {  {&_swigt__p_VecMat__Vec2Tint_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec2Tunsigned_int_t[] = {  {&_swigt__p_VecMat__Vec2Tunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec3Tdouble_t[] = {  {&_swigt__p_VecMat__Vec3Tdouble_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec3Tfloat_t[] = {  {&_swigt__p_VecMat__Vec3Tfloat_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec3Tint_t[] = {  {&_swigt__p_VecMat__Vec3Tint_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__Vec3Tunsigned_int_t[] = {  {&_swigt__p_VecMat__Vec3Tunsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTdouble_2_t[] = {  {&_swigt__p_VecMat__VecTdouble_2_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec2Tdouble_t, _p_VecMat__Vec2Tdouble_tTo_p_VecMat__VecTdouble_2_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTdouble_3_t[] = {  {&_swigt__p_VecMat__Vec3Tdouble_t, _p_VecMat__Vec3Tdouble_tTo_p_VecMat__VecTdouble_3_t, 0, 0},  {&_swigt__p_VecMat__VecTdouble_3_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTfloat_2_t[] = {  {&_swigt__p_VecMat__VecTfloat_2_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec2Tfloat_t, _p_VecMat__Vec2Tfloat_tTo_p_VecMat__VecTfloat_2_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTfloat_3_t[] = {  {&_swigt__p_VecMat__VecTfloat_3_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec3Tfloat_t, _p_VecMat__Vec3Tfloat_tTo_p_VecMat__VecTfloat_3_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTint_2_t[] = {  {&_swigt__p_VecMat__VecTint_2_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec2Tint_t, _p_VecMat__Vec2Tint_tTo_p_VecMat__VecTint_2_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTint_3_t[] = {  {&_swigt__p_VecMat__VecTint_3_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec3Tint_t, _p_VecMat__Vec3Tint_tTo_p_VecMat__VecTint_3_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTunsigned_int_2_t[] = {  {&_swigt__p_VecMat__VecTunsigned_int_2_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec2Tunsigned_int_t, _p_VecMat__Vec2Tunsigned_int_tTo_p_VecMat__VecTunsigned_int_2_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_VecMat__VecTunsigned_int_3_t[] = {  {&_swigt__p_VecMat__VecTunsigned_int_3_t, 0, 0, 0},  {&_swigt__p_VecMat__Vec3Tunsigned_int_t, _p_VecMat__Vec3Tunsigned_int_tTo_p_VecMat__VecTunsigned_int_3_t, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Vertex[] = {  {&_swigt__p_Vertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewEdge[] = {  {&_swigt__p_ViewEdge, 0, 0, 0},  {&_swigt__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewEdgeInternal__SVertexIterator[] = {  {&_swigt__p_ViewEdgeInternal__SVertexIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewEdgeInternal__ViewEdgeIterator[] = {  {&_swigt__p_ViewEdgeInternal__ViewEdgeIterator, 0, 0, 0},  {&_swigt__p_ChainingIterator, _p_ChainingIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator, 0, 0},  {&_swigt__p_ChainSilhouetteIterator, _p_ChainSilhouetteIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator, 0, 0},  {&_swigt__p_ChainPredicateIterator, _p_ChainPredicateIteratorTo_p_ViewEdgeInternal__ViewEdgeIterator, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewMap[] = {  {&_swigt__p_ViewMap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewShape[] = {  {&_swigt__p_ViewShape, 0, 0, 0},  {&_swigt__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertex[] = {  {&_swigt__p_TVertex, _p_TVertexTo_p_ViewVertex, 0, 0},  {&_swigt__p_NonTVertex, _p_NonTVertexTo_p_ViewVertex, 0, 0},  {&_swigt__p_ViewVertex, 0, 0, 0},  {&_swigt__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t[] = {  {&_swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t[] = {  {&_swigt__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertexInternal__orientedViewEdgeIterator[] = {  {&_swigt__p_ViewVertexInternal__orientedViewEdgeIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator[] = {  {&_swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator[] = {  {&_swigt__p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_const_edge_iterator[] = {  {&_swigt__p_const_edge_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_const_fedge_iterator[] = {  {&_swigt__p_const_fedge_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_const_point_iterator[] = {  {&_swigt__p_const_point_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_const_vertex_iterator[] = {  {&_swigt__p_const_vertex_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_directedViewEdge[] = {  {&_swigt__p_directedViewEdge, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_edge_iterator[] = {  {&_swigt__p_edge_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_edge_pointers_container[] = {  {&_swigt__p_edge_pointers_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_edges_container[] = {  {&_swigt__p_edges_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_fedge_iterator[] = {  {&_swigt__p_fedge_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_fedges_container[] = {  {&_swigt__p_fedges_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_id_to_index_map[] = {  {&_swigt__p_id_to_index_map, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_id_type[] = {  {&_swigt__p_id_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ltstr[] = {  {&_swigt__p_ltstr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_mapsMap[] = {  {&_swigt__p_mapsMap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_occluder_container__const_iterator[] = {  {&_swigt__p_occluder_container__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_point_iterator[] = {  {&_swigt__p_point_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_point_type[] = {  {&_swigt__p_point_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_setTVecMat__Vec3Tdouble_t_t[] = {  {&_swigt__p_setTVecMat__Vec3Tdouble_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t[] = {  {&_swigt__p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__pairTViewEdge_p_bool_t[] = {  {&_swigt__p_std__pairTViewEdge_p_bool_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t[] = {  {&_swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTMaterial_std__allocatorTMaterial_t_t[] = {  {&_swigt__p_std__vectorTMaterial_std__allocatorTMaterial_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t[] = {  {&_swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t[] = {  {&_swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t[] = {  {&_swigt__p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t[] = {  {&_swigt__p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t[] = {  {&_swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t[] = {  {&_swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t[] = {  {&_swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t[] = {  {&_swigt__p_std__vectorTint_std__allocatorTint_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type[] = {  {&_swigt__p_std__vectorTint_std__allocatorTint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t[] = {  {&_swigt__p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t[] = {  {&_swigt__p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_svertices_container[] = {  {&_swigt__p_svertices_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vertex_container[] = {  {&_swigt__p_vertex_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vertex_iterator[] = {  {&_swigt__p_vertex_iterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vertex_type[] = {  {&_swigt__p_vertex_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_viewedge_container[] = {  {&_swigt__p_viewedge_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_viewedges_container[] = {  {&_swigt__p_viewedges_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_viewshapes_container[] = {  {&_swigt__p_viewshapes_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_viewvertices_container[] = {  {&_swigt__p_viewvertices_container, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type[] = {  {&_swigt__p_FEdge, 0, 0, 0},  {&_swigt__p_FEdgeSharp, _p_FEdgeSharpTo_p_FEdge, 0, 0},  {&_swigt__p_FEdgeSmooth, _p_FEdgeSmoothTo_p_FEdge, 0, 0},  {&_swigt__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type[] = {  {&_swigt__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_SVertex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type[] = {  {&_swigt__p_StrokeShaders__ConstrainedIncreasingThicknessShader, _p_StrokeShaders__ConstrainedIncreasingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_StrokeShader, 0, 0, 0},  {&_swigt__p_StrokeShaders__ColorNoiseShader, _p_StrokeShaders__ColorNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ThicknessNoiseShader, _p_StrokeShaders__ThicknessNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__LengthDependingThicknessShader, _p_StrokeShaders__LengthDependingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__IncreasingThicknessShader, _p_StrokeShaders__IncreasingThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantExternThicknessShader, _p_StrokeShaders__ConstantExternThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantThicknessShader, _p_StrokeShaders__ConstantThicknessShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__StrokeTextureShader, _p_StrokeShaders__StrokeTextureShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__SamplingShader, _p_StrokeShaders__SamplingShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BSplineShader, _p_StrokeShaders__BSplineShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BezierCurveShader, _p_StrokeShaders__BezierCurveShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__InflateShader, _p_StrokeShaders__InflateShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__GuidingLinesShader, _p_StrokeShaders__GuidingLinesShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__streamShader, _p_StrokeShaders__streamShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__fstreamShader, _p_StrokeShaders__fstreamShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_CalligraphicShader, _p_CalligraphicShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_SpatialNoiseShader, _p_SpatialNoiseShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_SmoothingShader, _p_SmoothingShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__TextureAssignerShader, _p_StrokeShaders__TextureAssignerShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__CalligraphicColorShader, _p_StrokeShaders__CalligraphicColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__MaterialColorShader, _p_StrokeShaders__MaterialColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ColorVariationPatternShader, _p_StrokeShaders__ColorVariationPatternShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__IncreasingColorShader, _p_StrokeShaders__IncreasingColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ConstantColorShader, _p_StrokeShaders__ConstantColorShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ThicknessVariationPatternShader, _p_StrokeShaders__ThicknessVariationPatternShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__BackboneStretcherShader, _p_StrokeShaders__BackboneStretcherShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__ExternalContourStretcherShader, _p_StrokeShaders__ExternalContourStretcherShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__PolygonalizationShader, _p_StrokeShaders__PolygonalizationShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_StrokeShaders__TipRemoverShader, _p_StrokeShaders__TipRemoverShaderTo_p_StrokeShader, 0, 0},  {&_swigt__p_OmissionShader, _p_OmissionShaderTo_p_StrokeShader, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type[] = {  {&_swigt__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_ViewEdge, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type[] = {  {&_swigt__p_ViewShape, 0, 0, 0},  {&_swigt__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type[] = {  {&_swigt__p_TVertex, _p_TVertexTo_p_ViewVertex, 0, 0},  {&_swigt__p_NonTVertex, _p_NonTVertexTo_p_ViewVertex, 0, 0},  {&_swigt__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type, 0, 0, 0},  {&_swigt__p_ViewVertex, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_AdjacencyIterator,
+  _swigc__p_BBoxTVecMat__Vec3Tdouble_t_t,
+  _swigc__p_BinaryPredicate0D,
+  _swigc__p_BinaryPredicate1D,
+  _swigc__p_CalligraphicShader,
+  _swigc__p_Canvas,
+  _swigc__p_Chain,
+  _swigc__p_ChainPredicateIterator,
+  _swigc__p_ChainSilhouetteIterator,
+  _swigc__p_ChainingIterator,
+  _swigc__p_CurvatureInfo,
+  _swigc__p_Curve,
+  _swigc__p_CurveInternal__CurvePointIterator,
+  _swigc__p_CurvePoint,
+  _swigc__p_Curve__vertex_container__iterator,
+  _swigc__p_FEdge,
+  _swigc__p_FEdgeInternal__SVertexIterator,
+  _swigc__p_FEdgeSharp,
+  _swigc__p_FEdgeSmooth,
+  _swigc__p_Functions0D__Curvature2DAngleF0D,
+  _swigc__p_Functions0D__CurveNatureF0D,
+  _swigc__p_Functions0D__DensityF0D,
+  _swigc__p_Functions0D__GetCurvilinearAbscissaF0D,
+  _swigc__p_Functions0D__GetOccludeeF0D,
+  _swigc__p_Functions0D__GetOccludersF0D,
+  _swigc__p_Functions0D__GetParameterF0D,
+  _swigc__p_Functions0D__GetProjectedXF0D,
+  _swigc__p_Functions0D__GetProjectedYF0D,
+  _swigc__p_Functions0D__GetProjectedZF0D,
+  _swigc__p_Functions0D__GetShapeF0D,
+  _swigc__p_Functions0D__GetViewMapGradientNormF0D,
+  _swigc__p_Functions0D__GetXF0D,
+  _swigc__p_Functions0D__GetYF0D,
+  _swigc__p_Functions0D__GetZF0D,
+  _swigc__p_Functions0D__LocalAverageDepthF0D,
+  _swigc__p_Functions0D__MaterialF0D,
+  _swigc__p_Functions0D__Normal2DF0D,
+  _swigc__p_Functions0D__QuantitativeInvisibilityF0D,
+  _swigc__p_Functions0D__ReadCompleteViewMapPixelF0D,
+  _swigc__p_Functions0D__ReadMapPixelF0D,
+  _swigc__p_Functions0D__ReadSteerableViewMapPixelF0D,
+  _swigc__p_Functions0D__ShapeIdF0D,
+  _swigc__p_Functions0D__VertexOrientation2DF0D,
+  _swigc__p_Functions0D__VertexOrientation3DF0D,
+  _swigc__p_Functions0D__ZDiscontinuityF0D,
+  _swigc__p_Functions1D__ChainingTimeStampF1D,
+  _swigc__p_Functions1D__Curvature2DAngleF1D,
+  _swigc__p_Functions1D__CurveNatureF1D,
+  _swigc__p_Functions1D__DensityF1D,
+  _swigc__p_Functions1D__GetCompleteViewMapDensityF1D,
+  _swigc__p_Functions1D__GetDirectionalViewMapDensityF1D,
+  _swigc__p_Functions1D__GetOccludeeF1D,
+  _swigc__p_Functions1D__GetOccludersF1D,
+  _swigc__p_Functions1D__GetProjectedXF1D,
+  _swigc__p_Functions1D__GetProjectedYF1D,
+  _swigc__p_Functions1D__GetProjectedZF1D,
+  _swigc__p_Functions1D__GetShapeF1D,
+  _swigc__p_Functions1D__GetSteerableViewMapDensityF1D,
+  _swigc__p_Functions1D__GetViewMapGradientNormF1D,
+  _swigc__p_Functions1D__GetXF1D,
+  _swigc__p_Functions1D__GetYF1D,
+  _swigc__p_Functions1D__GetZF1D,
+  _swigc__p_Functions1D__IncrementChainingTimeStampF1D,
+  _swigc__p_Functions1D__LocalAverageDepthF1D,
+  _swigc__p_Functions1D__Normal2DF1D,
+  _swigc__p_Functions1D__Orientation2DF1D,
+  _swigc__p_Functions1D__Orientation3DF1D,
+  _swigc__p_Functions1D__QuantitativeInvisibilityF1D,
+  _swigc__p_Functions1D__TimeStampF1D,
+  _swigc__p_Functions1D__ZDiscontinuityF1D,
+  _swigc__p_GrayImage,
+  _swigc__p_I1DContainer,
+  _swigc__p_Id,
+  _swigc__p_IntegrationType,
+  _swigc__p_Interface0D,
+  _swigc__p_Interface0DIterator,
+  _swigc__p_Interface0DIteratorNested,
+  _swigc__p_Interface1D,
+  _swigc__p_Material,
+  _swigc__p_MediumType,
+  _swigc__p_Module,
+  _swigc__p_Noise,
+  _swigc__p_NonTVertex,
+  _swigc__p_OmissionShader,
+  _swigc__p_Omitter,
+  _swigc__p_Operators,
+  _swigc__p_Point,
+  _swigc__p_Polygon3r,
+  _swigc__p_Predicates0D__FalseUP0D,
+  _swigc__p_Predicates0D__TrueUP0D,
+  _swigc__p_Predicates1D__ContourUP1D,
+  _swigc__p_Predicates1D__DensityLowerThanUP1D,
+  _swigc__p_Predicates1D__EqualToChainingTimeStampUP1D,
+  _swigc__p_Predicates1D__EqualToTimeStampUP1D,
+  _swigc__p_Predicates1D__ExternalContourUP1D,
+  _swigc__p_Predicates1D__FalseBP1D,
+  _swigc__p_Predicates1D__FalseUP1D,
+  _swigc__p_Predicates1D__Length2DBP1D,
+  _swigc__p_Predicates1D__QuantitativeInvisibilityUP1D,
+  _swigc__p_Predicates1D__SameShapeIdBP1D,
+  _swigc__p_Predicates1D__ShapeUP1D,
+  _swigc__p_Predicates1D__TrueBP1D,
+  _swigc__p_Predicates1D__TrueUP1D,
+  _swigc__p_Predicates1D__ViewMapGradientNormBP1D,
+  _swigc__p_RGBImage,
+  _swigc__p_ReturnedValueType,
+  _swigc__p_SShape,
+  _swigc__p_SVertex,
+  _swigc__p_SVertex__fedges_container__iterator,
+  _swigc__p_Smoother,
+  _swigc__p_SmoothingShader,
+  _swigc__p_SpatialNoiseShader,
+  _swigc__p_SteerableViewMap,
+  _swigc__p_Stroke,
+  _swigc__p_StrokeAttribute,
+  _swigc__p_StrokeInternal__StrokeVertexIterator,
+  _swigc__p_StrokeLayer,
+  _swigc__p_StrokeRenderer,
+  _swigc__p_StrokeShader,
+  _swigc__p_StrokeShaders__BSplineShader,
+  _swigc__p_StrokeShaders__BackboneStretcherShader,
+  _swigc__p_StrokeShaders__BezierCurveShader,
+  _swigc__p_StrokeShaders__CalligraphicColorShader,
+  _swigc__p_StrokeShaders__ColorNoiseShader,
+  _swigc__p_StrokeShaders__ColorVariationPatternShader,
+  _swigc__p_StrokeShaders__ConstantColorShader,
+  _swigc__p_StrokeShaders__ConstantExternThicknessShader,
+  _swigc__p_StrokeShaders__ConstantThicknessShader,
+  _swigc__p_StrokeShaders__ConstrainedIncreasingThicknessShader,
+  _swigc__p_StrokeShaders__ExternalContourStretcherShader,
+  _swigc__p_StrokeShaders__GuidingLinesShader,
+  _swigc__p_StrokeShaders__IncreasingColorShader,
+  _swigc__p_StrokeShaders__IncreasingThicknessShader,
+  _swigc__p_StrokeShaders__InflateShader,
+  _swigc__p_StrokeShaders__LengthDependingThicknessShader,
+  _swigc__p_StrokeShaders__MaterialColorShader,
+  _swigc__p_StrokeShaders__PolygonalizationShader,
+  _swigc__p_StrokeShaders__SamplingShader,
+  _swigc__p_StrokeShaders__StrokeTextureShader,
+  _swigc__p_StrokeShaders__TextureAssignerShader,
+  _swigc__p_StrokeShaders__ThicknessNoiseShader,
+  _swigc__p_StrokeShaders__ThicknessVariationPatternShader,
+  _swigc__p_StrokeShaders__TipRemoverShader,
+  _swigc__p_StrokeShaders__fstreamShader,
+  _swigc__p_StrokeShaders__streamShader,
+  _swigc__p_StrokeVertex,
+  _swigc__p_Stroke__vertex_container__iterator,
+  _swigc__p_Stroke__viewedge_container__const_iterator,
+  _swigc__p_Stroke__viewedge_container__iterator,
+  _swigc__p_StrokesContainer,
+  _swigc__p_StyleModule,
+  _swigc__p_TVertex,
+  _swigc__p_UnaryFunction0DTId_t,
+  _swigc__p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t,
+  _swigc__p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t,
+  _swigc__p_UnaryFunction0DTViewShape_p_t,
+  _swigc__p_UnaryFunction0DTdouble_t,
+  _swigc__p_UnaryFunction0DTfloat_t,
+  _swigc__p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t,
+  _swigc__p_UnaryFunction0DTunsigned_int_t,
+  _swigc__p_UnaryFunction0DTvoid_t,
+  _swigc__p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t,
+  _swigc__p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t,
+  _swigc__p_UnaryFunction1DTdouble_t,
+  _swigc__p_UnaryFunction1DTfloat_t,
+  _swigc__p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t,
+  _swigc__p_UnaryFunction1DTunsigned_int_t,
+  _swigc__p_UnaryFunction1DTvoid_t,
+  _swigc__p_UnaryPredicate0D,
+  _swigc__p_UnaryPredicate1D,
+  _swigc__p_VecMat__HVec3Tdouble_t,
+  _swigc__p_VecMat__HVec3Tfloat_t,
+  _swigc__p_VecMat__HVec3Tint_t,
+  _swigc__p_VecMat__HVec3Tunsigned_int_t,
+  _swigc__p_VecMat__SquareMatrixTdouble_2_t,
+  _swigc__p_VecMat__SquareMatrixTdouble_3_t,
+  _swigc__p_VecMat__SquareMatrixTdouble_4_t,
+  _swigc__p_VecMat__SquareMatrixTfloat_2_t,
+  _swigc__p_VecMat__SquareMatrixTfloat_3_t,
+  _swigc__p_VecMat__SquareMatrixTfloat_4_t,
+  _swigc__p_VecMat__SquareMatrixTint_2_t,
+  _swigc__p_VecMat__SquareMatrixTint_3_t,
+  _swigc__p_VecMat__SquareMatrixTint_4_t,
+  _swigc__p_VecMat__SquareMatrixTunsigned_int_2_t,
+  _swigc__p_VecMat__SquareMatrixTunsigned_int_3_t,
+  _swigc__p_VecMat__SquareMatrixTunsigned_int_4_t,
+  _swigc__p_VecMat__Vec2Tdouble_t,
+  _swigc__p_VecMat__Vec2Tfloat_t,
+  _swigc__p_VecMat__Vec2Tint_t,
+  _swigc__p_VecMat__Vec2Tunsigned_int_t,
+  _swigc__p_VecMat__Vec3Tdouble_t,
+  _swigc__p_VecMat__Vec3Tfloat_t,
+  _swigc__p_VecMat__Vec3Tint_t,
+  _swigc__p_VecMat__Vec3Tunsigned_int_t,
+  _swigc__p_VecMat__VecTdouble_2_t,
+  _swigc__p_VecMat__VecTdouble_3_t,
+  _swigc__p_VecMat__VecTfloat_2_t,
+  _swigc__p_VecMat__VecTfloat_3_t,
+  _swigc__p_VecMat__VecTint_2_t,
+  _swigc__p_VecMat__VecTint_3_t,
+  _swigc__p_VecMat__VecTunsigned_int_2_t,
+  _swigc__p_VecMat__VecTunsigned_int_3_t,
+  _swigc__p_Vertex,
+  _swigc__p_ViewEdge,
+  _swigc__p_ViewEdgeInternal__SVertexIterator,
+  _swigc__p_ViewEdgeInternal__ViewEdgeIterator,
+  _swigc__p_ViewMap,
+  _swigc__p_ViewShape,
+  _swigc__p_ViewVertex,
+  _swigc__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t,
+  _swigc__p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t,
+  _swigc__p_ViewVertexInternal__orientedViewEdgeIterator,
+  _swigc__p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator,
+  _swigc__p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator,
+  _swigc__p_allocator_type,
+  _swigc__p_char,
+  _swigc__p_const_edge_iterator,
+  _swigc__p_const_fedge_iterator,
+  _swigc__p_const_point_iterator,
+  _swigc__p_const_reference,
+  _swigc__p_const_vertex_iterator,
+  _swigc__p_difference_type,
+  _swigc__p_directedViewEdge,
+  _swigc__p_double,
+  _swigc__p_edge_iterator,
+  _swigc__p_edge_pointers_container,
+  _swigc__p_edges_container,
+  _swigc__p_fedge_iterator,
+  _swigc__p_fedges_container,
+  _swigc__p_float,
+  _swigc__p_id_to_index_map,
+  _swigc__p_id_type,
+  _swigc__p_int,
+  _swigc__p_ltstr,
+  _swigc__p_mapsMap,
+  _swigc__p_occluder_container__const_iterator,
+  _swigc__p_p_PyObject,
+  _swigc__p_point_iterator,
+  _swigc__p_point_type,
+  _swigc__p_reference,
+  _swigc__p_setTVecMat__Vec3Tdouble_t_t,
+  _swigc__p_size_type,
+  _swigc__p_std__invalid_argument,
+  _swigc__p_std__mapTint_int_std__lessTint_t_std__allocatorTstd__pairTint_const_int_t_t_t,
+  _swigc__p_std__pairTViewEdge_p_bool_t,
+  _swigc__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t,
+  _swigc__p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type,
+  _swigc__p_std__vectorTMaterial_std__allocatorTMaterial_t_t,
+  _swigc__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t,
+  _swigc__p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type,
+  _swigc__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t,
+  _swigc__p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type,
+  _swigc__p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t,
+  _swigc__p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t,
+  _swigc__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t,
+  _swigc__p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type,
+  _swigc__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t,
+  _swigc__p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type,
+  _swigc__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t,
+  _swigc__p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type,
+  _swigc__p_std__vectorTint_std__allocatorTint_t_t,
+  _swigc__p_std__vectorTint_std__allocatorTint_t_t__allocator_type,
+  _swigc__p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t,
+  _swigc__p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t,
+  _swigc__p_svertices_container,
+  _swigc__p_swig__PySwigIterator,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_short,
+  _swigc__p_value_type,
+  _swigc__p_vertex_container,
+  _swigc__p_vertex_iterator,
+  _swigc__p_vertex_type,
+  _swigc__p_viewedge_container,
+  _swigc__p_viewedges_container,
+  _swigc__p_viewshapes_container,
+  _swigc__p_viewvertices_container,
+  _swigc__p_void,
+  _swigc__std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type,
+  _swigc__std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type,
+  _swigc__std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type,
+  _swigc__std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type,
+  _swigc__std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type,
+  _swigc__std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+static swig_const_info swig_const_table[] = {
+{0, 0, 0, 0.0, 0, 0}};
+
+#ifdef __cplusplus
+}
+#endif
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic 
+ * memory is used. Also, since swig_type_info structures store pointers to 
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization. 
+ * The idea is that swig generates all the structures that are needed. 
+ * The runtime then collects these partially filled structures. 
+ * The SWIG_InitializeModule function takes these initial arrays out of 
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned staticly to an initial 
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it 
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded. 
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the 
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int found;
+  
+  clientdata = clientdata;
+  
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+  }
+  
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+    module_head = &swig_module;
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    found=0;
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        found=1;
+        break;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+    
+    /* if the is found in the list, then all is done and we may leave */
+    if (found) return;
+    /* otherwise we must add out module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+  
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+    
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+    
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+        type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+    
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+        if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+          cast->type = ret;
+          ret = 0;
+        } else {
+          /* Check for casting already in the list */
+          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+          if (!ocast) ret = 0;
+        }
+      }
+      
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+  
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+    printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+  
+  if (init_run) return;
+  init_run = 1;
+  
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{
+  /* c-mode */
+#endif
+}
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  
+  /* Python-specific SWIG API */
+#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
+#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
+#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
+  
+  /* -----------------------------------------------------------------------------
+   * global variable support code.
+   * ----------------------------------------------------------------------------- */
+  
+  typedef struct swig_globalvar {
+    char       *name;                  /* Name of global variable */
+    PyObject *(*get_attr)(void);       /* Return the current value */
+    int       (*set_attr)(PyObject *); /* Set the value */
+    struct swig_globalvar *next;
+  } swig_globalvar;
+  
+  typedef struct swig_varlinkobject {
+    PyObject_HEAD
+    swig_globalvar *vars;
+  } swig_varlinkobject;
+  
+  SWIGINTERN PyObject *
+  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
+    return PyString_FromString("<Swig global variables>");
+  }
+  
+  SWIGINTERN PyObject *
+  swig_varlink_str(swig_varlinkobject *v) {
+    PyObject *str = PyString_FromString("(");
+    swig_globalvar  *var;
+    for (var = v->vars; var; var=var->next) {
+      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
+      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
+    }
+    PyString_ConcatAndDel(&str,PyString_FromString(")"));
+    return str;
+  }
+  
+  SWIGINTERN int
+  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
+    PyObject *str = swig_varlink_str(v);
+    fprintf(fp,"Swig global variables ");
+    fprintf(fp,"%s\n", PyString_AsString(str));
+    Py_DECREF(str);
+    return 0;
+  }
+  
+  SWIGINTERN void
+  swig_varlink_dealloc(swig_varlinkobject *v) {
+    swig_globalvar *var = v->vars;
+    while (var) {
+      swig_globalvar *n = var->next;
+      free(var->name);
+      free(var);
+      var = n;
+    }
+  }
+  
+  SWIGINTERN PyObject *
+  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
+    PyObject *res = NULL;
+    swig_globalvar *var = v->vars;
+    while (var) {
+      if (strcmp(var->name,n) == 0) {
+        res = (*var->get_attr)();
+        break;
+      }
+      var = var->next;
+    }
+    if (res == NULL && !PyErr_Occurred()) {
+      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+    }
+    return res;
+  }
+  
+  SWIGINTERN int
+  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
+    int res = 1;
+    swig_globalvar *var = v->vars;
+    while (var) {
+      if (strcmp(var->name,n) == 0) {
+        res = (*var->set_attr)(p);
+        break;
+      }
+      var = var->next;
+    }
+    if (res == 1 && !PyErr_Occurred()) {
+      PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+    }
+    return res;
+  }
+  
+  SWIGINTERN PyTypeObject*
+  swig_varlink_type(void) {
+    static char varlink__doc__[] = "Swig var link object";
+    static PyTypeObject varlink_type;
+    static int type_init = 0;  
+    if (!type_init) {
+      const PyTypeObject tmp
+      = {
+        PyObject_HEAD_INIT(NULL)
+        0,                                  /* Number of items in variable part (ob_size) */
+        (char *)"swigvarlink",              /* Type name (tp_name) */
+        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
+        0,                                  /* Itemsize (tp_itemsize) */
+        (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
+        (printfunc) swig_varlink_print,     /* Print (tp_print) */
+        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
+        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
+        0,                                  /* tp_compare */
+        (reprfunc) swig_varlink_repr,       /* tp_repr */
+        0,                                  /* tp_as_number */
+        0,                                  /* tp_as_sequence */
+        0,                                  /* tp_as_mapping */
+        0,                                  /* tp_hash */
+        0,                                  /* tp_call */
+        (reprfunc)swig_varlink_str,        /* tp_str */
+        0,                                  /* tp_getattro */
+        0,                                  /* tp_setattro */
+        0,                                  /* tp_as_buffer */
+        0,                                  /* tp_flags */
+        varlink__doc__,                     /* tp_doc */
+        0,                                  /* tp_traverse */
+        0,                                  /* tp_clear */
+        0,                                  /* tp_richcompare */
+        0,                                  /* tp_weaklistoffset */
+#if PY_VERSION_HEX >= 0x02020000
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
+#endif
+#if PY_VERSION_HEX >= 0x02030000
+        0,                                  /* tp_del */
+#endif
+#ifdef COUNT_ALLOCS
+        0,0,0,0                             /* tp_alloc -> tp_next */
+#endif
+      };
+      varlink_type = tmp;
+      varlink_type.ob_type = &PyType_Type;
+      type_init = 1;
+    }
+    return &varlink_type;
+  }
+  
+  /* Create a variable linking object for use later */
+  SWIGINTERN PyObject *
+  SWIG_Python_newvarlink(void) {
+    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
+    if (result) {
+      result->vars = 0;
+    }
+    return ((PyObject*) result);
+  }
+  
+  SWIGINTERN void 
+  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
+    swig_varlinkobject *v = (swig_varlinkobject *) p;
+    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
+    if (gv) {
+      size_t size = strlen(name)+1;
+      gv->name = (char *)malloc(size);
+      if (gv->name) {
+        strncpy(gv->name,name,size);
+        gv->get_attr = get_attr;
+        gv->set_attr = set_attr;
+        gv->next = v->vars;
+      }
+    }
+    v->vars = gv;
+  }
+  
+  SWIGINTERN PyObject *
+  SWIG_globals(void) {
+    static PyObject *_SWIG_globals = 0; 
+    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
+    return _SWIG_globals;
+  }
+  
+  /* -----------------------------------------------------------------------------
+   * constants/methods manipulation
+   * ----------------------------------------------------------------------------- */
+  
+  /* Install Constants */
+  SWIGINTERN void
+  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
+    PyObject *obj = 0;
+    size_t i;
+    for (i = 0; constants[i].type; ++i) {
+      switch(constants[i].type) {
+      case SWIG_PY_POINTER:
+        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
+        break;
+      case SWIG_PY_BINARY:
+        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
+        break;
+      default:
+        obj = 0;
+        break;
+      }
+      if (obj) {
+        PyDict_SetItemString(d, constants[i].name, obj);
+        Py_DECREF(obj);
+      }
+    }
+  }
+  
+  /* -----------------------------------------------------------------------------*/
+  /* Fix SwigMethods to carry the callback ptrs when needed */
+  /* -----------------------------------------------------------------------------*/
+  
+  SWIGINTERN void
+  SWIG_Python_FixMethods(PyMethodDef *methods,
+    swig_const_info *const_table,
+    swig_type_info **types,
+    swig_type_info **types_initial) {
+    size_t i;
+    for (i = 0; methods[i].ml_name; ++i) {
+      const char *c = methods[i].ml_doc;
+      if (c && (c = strstr(c, "swig_ptr: "))) {
+        int j;
+        swig_const_info *ci = 0;
+        const char *name = c + 10;
+        for (j = 0; const_table[j].type; ++j) {
+          if (strncmp(const_table[j].name, name, 
+              strlen(const_table[j].name)) == 0) {
+            ci = &(const_table[j]);
+            break;
+          }
+        }
+        if (ci) {
+          size_t shift = (ci->ptype) - types;
+          swig_type_info *ty = types_initial[shift];
+          size_t ldoc = (c - methods[i].ml_doc);
+          size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
+          char *ndoc = (char*)malloc(ldoc + lptr + 10);
+          if (ndoc) {
+            char *buff = ndoc;
+            void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
+            if (ptr) {
+              strncpy(buff, methods[i].ml_doc, ldoc);
+              buff += ldoc;
+              strncpy(buff, "swig_ptr: ", 10);
+              buff += 10;
+              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
+              methods[i].ml_doc = ndoc;
+            }
+          }
+        }
+      }
+    }
+  } 
+  
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------*
+ *  Partial Init method
+ * -----------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void SWIG_init(void) {
+  PyObject *m, *d;
+  
+  /* Fix SwigMethods to carry the callback ptrs when needed */
+  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
+  
+  m = Py_InitModule((char *) SWIG_name, SwigMethods);
+  d = PyModule_GetDict(m);
+  
+  SWIG_InitializeModule(0);
+  SWIG_InstallConstants(d,swig_const_table);
+  
+  
+  SWIG_Python_SetConstant(d, "_Noise_B_",SWIG_From_int(static_cast< int >(0x100)));
+  PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
+  SWIG_addvarlink(SWIG_globals(),(char*)"POINT",POINT_get, POINT_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"S_VERTEX",S_VERTEX_get, S_VERTEX_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"VIEW_VERTEX",VIEW_VERTEX_get, VIEW_VERTEX_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"NON_T_VERTEX",NON_T_VERTEX_get, NON_T_VERTEX_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"T_VERTEX",T_VERTEX_get, T_VERTEX_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"CUSP",CUSP_get, CUSP_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"NO_FEATURE",NO_FEATURE_get, NO_FEATURE_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"SILHOUETTE",SILHOUETTE_get, SILHOUETTE_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"BORDER",BORDER_get, BORDER_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"CREASE",CREASE_get, CREASE_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"RIDGE",RIDGE_get, RIDGE_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"VALLEY",VALLEY_get, VALLEY_set);
+  SWIG_addvarlink(SWIG_globals(),(char*)"SUGGESTIVE_CONTOUR",SUGGESTIVE_CONTOUR_get, SUGGESTIVE_CONTOUR_set);
+  SWIG_Python_SetConstant(d, "MEAN",SWIG_From_int(static_cast< int >(MEAN)));
+  SWIG_Python_SetConstant(d, "MIN",SWIG_From_int(static_cast< int >(MIN)));
+  SWIG_Python_SetConstant(d, "MAX",SWIG_From_int(static_cast< int >(MAX)));
+  SWIG_Python_SetConstant(d, "FIRST",SWIG_From_int(static_cast< int >(FIRST)));
+  SWIG_Python_SetConstant(d, "LAST",SWIG_From_int(static_cast< int >(LAST)));
+  SWIG_Python_SetConstant(d, "Stroke_DRY_MEDIUM",SWIG_From_int(static_cast< int >(Stroke::DRY_MEDIUM)));
+  SWIG_Python_SetConstant(d, "Stroke_HUMID_MEDIUM",SWIG_From_int(static_cast< int >(Stroke::HUMID_MEDIUM)));
+  SWIG_Python_SetConstant(d, "Stroke_OPAQUE_MEDIUM",SWIG_From_int(static_cast< int >(Stroke::OPAQUE_MEDIUM)));
+  SWIG_Python_SetConstant(d, "Canvas_NB_STEERABLE_VIEWMAP",SWIG_From_int(static_cast< int >(Canvas::NB_STEERABLE_VIEWMAP)));
+}
+
diff --git a/source/blender/freestyle/intern/swig/ModuleWrapper.h b/source/blender/freestyle/intern/swig/ModuleWrapper.h
new file mode 100755
index 00000000000..06ca8c90f37
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/ModuleWrapper.h
@@ -0,0 +1,1045 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.31
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_Freestyle_WRAP_H_
+#define SWIG_Freestyle_WRAP_H_
+
+#include <map>
+#include <string>
+
+
+class SwigDirector_ViewEdgeViewEdgeIterator : public ViewEdgeInternal::ViewEdgeIterator, public Swig::Director {
+
+public:
+    SwigDirector_ViewEdgeViewEdgeIterator(PyObject *self, ViewEdge *begin = 0, bool orientation = true);
+    SwigDirector_ViewEdgeViewEdgeIterator(PyObject *self, ViewEdgeInternal::ViewEdgeIterator const &it);
+    virtual ~SwigDirector_ViewEdgeViewEdgeIterator();
+    virtual std::string getExactTypeName() const;
+    virtual ViewEdge *operator *();
+    virtual ViewEdge *operator ->();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator ++();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator ++(int arg0);
+    virtual void increment();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator --();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator --(int arg0);
+    virtual void decrement();
+    virtual bool isBegin() const;
+    virtual bool isEnd() const;
+    virtual bool operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual bool operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const;
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class ViewEdgeViewEdgeIterator doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[9];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DVoid : public UnaryFunction0D<void >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DVoid(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DVoid();
+    virtual std::string getName() const;
+    virtual void operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DVoid doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DUnsigned : public UnaryFunction0D<unsigned int >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DUnsigned(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DUnsigned();
+    virtual std::string getName() const;
+    virtual unsigned int operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DUnsigned doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DFloat : public UnaryFunction0D<float >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DFloat(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DFloat();
+    virtual std::string getName() const;
+    virtual float operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DFloat doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DDouble : public UnaryFunction0D<double >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DDouble(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DDouble();
+    virtual std::string getName() const;
+    virtual double operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DDouble doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DVec2f : public UnaryFunction0D<Geometry::Vec2f >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DVec2f(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DVec2f();
+    virtual std::string getName() const;
+    virtual VecMat::Vec2<float > operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DVec2f doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DVec3f : public UnaryFunction0D<Geometry::Vec3f >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DVec3f(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DVec3f();
+    virtual std::string getName() const;
+    virtual VecMat::Vec3<float > operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DVec3f doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction0DId : public UnaryFunction0D<Id >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction0DId(PyObject *self);
+    virtual ~SwigDirector_UnaryFunction0DId();
+    virtual std::string getName() const;
+    virtual Id operator ()(Interface0DIterator &iter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction0DId doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DVoid : public UnaryFunction1D<void >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DVoid(PyObject *self);
+    SwigDirector_UnaryFunction1DVoid(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DVoid();
+    virtual std::string getName() const;
+    virtual void operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DVoid doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DUnsigned : public UnaryFunction1D<unsigned int >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DUnsigned(PyObject *self);
+    SwigDirector_UnaryFunction1DUnsigned(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DUnsigned();
+    virtual std::string getName() const;
+    virtual unsigned int operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DUnsigned doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DFloat : public UnaryFunction1D<float >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DFloat(PyObject *self);
+    SwigDirector_UnaryFunction1DFloat(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DFloat();
+    virtual std::string getName() const;
+    virtual float operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DFloat doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DDouble : public UnaryFunction1D<double >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DDouble(PyObject *self);
+    SwigDirector_UnaryFunction1DDouble(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DDouble();
+    virtual std::string getName() const;
+    virtual double operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DDouble doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DVec2f : public UnaryFunction1D<Geometry::Vec2f >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DVec2f(PyObject *self);
+    SwigDirector_UnaryFunction1DVec2f(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DVec2f();
+    virtual std::string getName() const;
+    virtual VecMat::Vec2<float > operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DVec2f doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryFunction1DVec3f : public UnaryFunction1D<Geometry::Vec3f >, public Swig::Director {
+
+public:
+    SwigDirector_UnaryFunction1DVec3f(PyObject *self);
+    SwigDirector_UnaryFunction1DVec3f(PyObject *self, IntegrationType iType);
+    virtual ~SwigDirector_UnaryFunction1DVec3f();
+    virtual std::string getName() const;
+    virtual VecMat::Vec3<float > operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryFunction1DVec3f doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_ChainingIterator : public ChainingIterator, public Swig::Director {
+
+public:
+    SwigDirector_ChainingIterator(PyObject *self, bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge *begin = 0, bool orientation = true);
+    SwigDirector_ChainingIterator(PyObject *self, ChainingIterator const &brother);
+    virtual ~SwigDirector_ChainingIterator();
+    virtual std::string getExactTypeName() const;
+    virtual ViewEdge *operator *();
+    virtual ViewEdge *operator ->();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator ++();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator ++(int arg0);
+    virtual void increment();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator --();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator --(int arg0);
+    virtual void decrement();
+    virtual bool isBegin() const;
+    virtual bool isEnd() const;
+    virtual bool operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual bool operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual void init();
+    virtual ViewEdge *traverse(AdjacencyIterator const &it);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class ChainingIterator doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[11];
+#endif
+
+};
+
+
+class SwigDirector_ChainSilhouetteIterator : public ChainSilhouetteIterator, public Swig::Director {
+
+public:
+    SwigDirector_ChainSilhouetteIterator(PyObject *self, bool iRestrictToSelection = true, ViewEdge *begin = NULL, bool orientation = true);
+    SwigDirector_ChainSilhouetteIterator(PyObject *self, ChainSilhouetteIterator const &brother);
+    virtual ~SwigDirector_ChainSilhouetteIterator();
+    virtual std::string getExactTypeName() const;
+    virtual ViewEdge *operator *();
+    virtual ViewEdge *operator ->();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator ++();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator ++(int arg0);
+    virtual void increment();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator --();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator --(int arg0);
+    virtual void decrement();
+    virtual bool isBegin() const;
+    virtual bool isEnd() const;
+    virtual bool operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual bool operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual void init();
+    virtual ViewEdge *traverse(AdjacencyIterator const &it);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class ChainSilhouetteIterator doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[11];
+#endif
+
+};
+
+
+class SwigDirector_ChainPredicateIterator : public ChainPredicateIterator, public Swig::Director {
+
+public:
+    SwigDirector_ChainPredicateIterator(PyObject *self, bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge *begin = NULL, bool orientation = true);
+    SwigDirector_ChainPredicateIterator(PyObject *self, UnaryPredicate1D &upred, BinaryPredicate1D &bpred, bool iRestrictToSelection = true, bool iRestrictToUnvisited = true, ViewEdge *begin = NULL, bool orientation = true);
+    SwigDirector_ChainPredicateIterator(PyObject *self, ChainPredicateIterator const &brother);
+    virtual ~SwigDirector_ChainPredicateIterator();
+    virtual std::string getExactTypeName() const;
+    virtual ViewEdge *operator *();
+    virtual ViewEdge *operator ->();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator ++();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator ++(int arg0);
+    virtual void increment();
+    virtual ViewEdgeInternal::ViewEdgeIterator &operator --();
+    virtual ViewEdgeInternal::ViewEdgeIterator operator --(int arg0);
+    virtual void decrement();
+    virtual bool isBegin() const;
+    virtual bool isEnd() const;
+    virtual bool operator ==(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual bool operator !=(ViewEdgeInternal::ViewEdgeIterator &it) const;
+    virtual void init();
+    virtual ViewEdge *traverse(AdjacencyIterator const &it);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class ChainPredicateIterator doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[11];
+#endif
+
+};
+
+
+class SwigDirector_UnaryPredicate0D : public UnaryPredicate0D, public Swig::Director {
+
+public:
+    SwigDirector_UnaryPredicate0D(PyObject *self);
+    virtual ~SwigDirector_UnaryPredicate0D();
+    virtual std::string getName() const;
+    virtual bool operator ()(Interface0DIterator &it);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryPredicate0D doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_UnaryPredicate1D : public UnaryPredicate1D, public Swig::Director {
+
+public:
+    SwigDirector_UnaryPredicate1D(PyObject *self);
+    virtual ~SwigDirector_UnaryPredicate1D();
+    virtual std::string getName() const;
+    virtual bool operator ()(Interface1D &inter);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class UnaryPredicate1D doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_BinaryPredicate1D : public BinaryPredicate1D, public Swig::Director {
+
+public:
+    SwigDirector_BinaryPredicate1D(PyObject *self);
+    virtual ~SwigDirector_BinaryPredicate1D();
+    virtual std::string getName() const;
+    virtual bool operator ()(Interface1D &inter1, Interface1D &inter2);
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class BinaryPredicate1D doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+class SwigDirector_StrokeShader : public StrokeShader, public Swig::Director {
+
+public:
+    SwigDirector_StrokeShader(PyObject *self);
+    virtual ~SwigDirector_StrokeShader();
+    virtual std::string getName() const;
+    virtual void shade(Stroke &ioStroke) const;
+
+
+/* Internal Director utilities */
+public:
+    bool swig_get_inner(const char* name) const {
+      std::map<std::string, bool>::const_iterator iv = inner.find(name);
+      return (iv != inner.end() ? iv->second : false);
+    }
+
+    void swig_set_inner(const char* name, bool val) const
+    { inner[name] = val;}
+
+private:
+    mutable std::map<std::string, bool> inner;
+
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::PyObject_var name = PyString_FromString(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (method == NULL) {
+          std::string msg = "Method in class StrokeShader doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      };
+      return method;
+    }
+private:
+    mutable swig::PyObject_var vtable[2];
+#endif
+
+};
+
+
+#endif
diff --git a/source/blender/freestyle/intern/system/BaseIterator.h b/source/blender/freestyle/intern/system/BaseIterator.h
new file mode 100755
index 00000000000..45cc19df4fe
--- /dev/null
+++ b/source/blender/freestyle/intern/system/BaseIterator.h
@@ -0,0 +1,90 @@
+//
+//  Filename         : BaseIterator.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes defining the basic "Iterator" design pattern
+//  Date of creation : 18/03/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  BASEITERATOR_H
+# define BASEITERATOR_H
+
+# include <iterator>
+
+// use for iterators defintions
+template <class Element>
+class Nonconst_traits;
+
+template <class Element>
+class Const_traits {
+public:
+  typedef Element value_type;
+  typedef const Element&  reference;
+  typedef const Element*  pointer;
+  typedef ptrdiff_t       difference_type;
+  typedef Nonconst_traits<Element> Non_const_traits;
+};
+
+template <class Element>
+class Nonconst_traits {
+public:
+  typedef Element value_type;
+  typedef Element& reference;
+  typedef Element* pointer;
+  typedef ptrdiff_t       difference_type;
+  typedef Nonconst_traits<Element> Non_const_traits;
+};
+
+class InputIteratorTag_Traits {
+public:
+  typedef std::input_iterator_tag iterator_category;
+};
+
+class BidirectionalIteratorTag_Traits {
+public:
+  typedef std::bidirectional_iterator_tag iterator_category;
+};
+
+template<class Traits, class IteratorTagTraits>
+class IteratorBase
+{
+public:
+
+  virtual ~IteratorBase() {}
+
+  virtual bool begin() const = 0;
+  virtual bool end() const = 0;
+
+  typedef typename IteratorTagTraits::iterator_category     iterator_category;
+  typedef typename Traits::value_type                       value_type;
+  typedef typename Traits::difference_type                  difference_type;
+  typedef typename Traits::pointer                          pointer;
+  typedef typename Traits::reference                        reference;
+
+protected:
+
+  IteratorBase() {}
+};
+
+#endif // BASEITERATOR_H
diff --git a/source/blender/freestyle/intern/system/BaseObject.cpp b/source/blender/freestyle/intern/system/BaseObject.cpp
new file mode 100755
index 00000000000..21d8a77b268
--- /dev/null
+++ b/source/blender/freestyle/intern/system/BaseObject.cpp
@@ -0,0 +1 @@
+#include "BaseObject.h"
\ No newline at end of file
diff --git a/source/blender/freestyle/intern/system/BaseObject.h b/source/blender/freestyle/intern/system/BaseObject.h
new file mode 100755
index 00000000000..a8515f98385
--- /dev/null
+++ b/source/blender/freestyle/intern/system/BaseObject.h
@@ -0,0 +1,73 @@
+//
+//  Filename         : BaseObject.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Base Class for most shared objects (Node, Rep).
+//                     Defines the addRef, release system.
+//                     Inspired by COM IUnknown system.
+//  Date of creation : 06/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  BASEOBJECT_H
+# define BASEOBJECT_H
+
+#include "FreestyleConfig.h"
+
+class LIB_SYSTEM_EXPORT BaseObject
+{
+public:
+
+  inline BaseObject() {
+    _ref_counter = 0;
+  }
+
+  virtual ~BaseObject() {}
+
+  /*! At least makes a release on this.
+   *  The BaseObject::destroy method must be 
+   *  explicitely called at the end of any 
+   *  overloaded destroy
+   */
+  virtual int destroy() {
+    return release();
+  }
+
+  /*! Increments the reference counter */
+  inline int addRef() {
+    return ++_ref_counter;
+  }
+
+  /*! Decrements the reference counter */
+  inline int release() { 
+    if (_ref_counter)
+      _ref_counter--;
+    return _ref_counter;
+  }
+
+private:
+
+  unsigned _ref_counter;  
+};
+
+#endif // BASEOBJECT_H
diff --git a/source/blender/freestyle/intern/system/Cast.h b/source/blender/freestyle/intern/system/Cast.h
new file mode 100755
index 00000000000..15af767443e
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Cast.h
@@ -0,0 +1,44 @@
+//
+//  Filename         : Cast.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Cast function
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  CAST_HPP
+# define CAST_HPP
+
+namespace Cast {
+
+  template <class T, class U>
+  U* cast(T* in) {
+    if (!in)
+      return NULL;
+    return dynamic_cast<U*>(in);
+  }
+
+} // end of namespace Cast
+
+#endif // CAST_HPP
diff --git a/source/blender/freestyle/intern/system/Exception.cpp b/source/blender/freestyle/intern/system/Exception.cpp
new file mode 100755
index 00000000000..d1d12d18297
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Exception.cpp
@@ -0,0 +1,24 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Exception.h"
+
+Exception::exception_type Exception::_exception = Exception::NO_EXCEPTION;
diff --git a/source/blender/freestyle/intern/system/Exception.h b/source/blender/freestyle/intern/system/Exception.h
new file mode 100755
index 00000000000..378de6b558f
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Exception.h
@@ -0,0 +1,64 @@
+//
+//  Filename         : Exception.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Singleton to manage exceptions
+//  Date of creation : 10/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  EXCEPTION_H
+# define EXCEPTION_H
+
+# include "FreestyleConfig.h"
+
+class LIB_SYSTEM_EXPORT Exception
+{
+public:
+
+  typedef enum {
+    NO_EXCEPTION,
+    UNDEFINED
+  } exception_type;
+
+  static int getException() {
+    exception_type e = _exception;
+    _exception = NO_EXCEPTION;
+    return e;
+  } 
+
+  static int raiseException(exception_type exception = UNDEFINED) {
+    _exception = exception;
+    return _exception;
+  }
+
+  static void reset() {
+    _exception = NO_EXCEPTION;
+  }
+
+private:
+
+  static exception_type _exception;
+};
+
+#endif // EXCEPTION_H
diff --git a/source/blender/freestyle/intern/system/FreestyleConfig.h b/source/blender/freestyle/intern/system/FreestyleConfig.h
new file mode 100755
index 00000000000..45bd00a402e
--- /dev/null
+++ b/source/blender/freestyle/intern/system/FreestyleConfig.h
@@ -0,0 +1,152 @@
+//
+//  Filename         : Config.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Configuration definitions
+//  Date of creation : 25/02/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef  CONFIG_H
+# define CONFIG_H
+
+# include <string>
+
+using namespace std;
+
+namespace Config {
+
+  // Pi definition
+# ifndef M_PI
+#  define M_PI 3.14159265
+# endif // M_PI
+
+  // Directory separators
+# ifdef WIN32
+  static const string DIR_SEP("\\");
+  static const string PATH_SEP(";");
+# else
+  static const string DIR_SEP("/");
+  static const string PATH_SEP(":");
+# endif // WIN32
+
+  // DLL import/export macros for Win32
+
+# ifdef WIN32
+#  ifdef MAKE_LIB_SYSTEM_DLL
+#   define LIB_SYSTEM_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_SYSTEM_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_SYSTEM_DLL
+
+#  ifdef MAKE_LIB_IMAGE_DLL
+#   define LIB_IMAGE_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_IMAGE_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_IMAGE_DLL
+
+#  ifdef MAKE_LIB_GEOMETRY_DLL
+#   define LIB_GEOMETRY_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_GEOMETRY_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_GEOMETRY_DLL
+
+#  ifdef MAKE_LIB_SCENE_GRAPH_DLL
+#   define LIB_SCENE_GRAPH_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_SCENE_GRAPH_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_SCENE_GRAPH_DLL
+
+#  ifdef MAKE_LIB_WINGED_EDGE_DLL
+#   define LIB_WINGED_EDGE_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_WINGED_EDGE_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_WINGED_EDGE_DLL
+
+#  ifdef MAKE_LIB_VIEW_MAP_DLL
+#   define LIB_VIEW_MAP_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_VIEW_MAP_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_VIEW_MAP_DLL
+
+#  ifdef MAKE_LIB_STROKE_DLL
+#   define LIB_STROKE_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_STROKE_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_STROKE_DLL
+
+#  ifdef MAKE_LIB_RENDERING_DLL
+#   define LIB_RENDERING_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_RENDERING_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_RENDERING_DLL
+
+#  ifdef MAKE_LIB_WRAPPER_DLL
+#   define LIB_WRAPPER_EXPORT __declspec(dllexport)
+#  else
+#   define LIB_WRAPPER_EXPORT __declspec(dllimport)
+#  endif // MAKE_LIB_WRAPPER_DLL
+
+# else
+#  ifndef LIB_SYSTEM_EXPORT
+#   define LIB_SYSTEM_EXPORT
+#  endif // LIB_SYSTEM_EXPORT
+
+#  ifndef LIB_IMAGE_EXPORT
+#   define LIB_IMAGE_EXPORT
+#  endif // LIB_IMAGE_EXPORT
+
+#  ifndef LIB_GEOMETRY_EXPORT
+#   define LIB_GEOMETRY_EXPORT
+#  endif // LIB_GEOMETRY_EXPORT
+
+#  ifndef LIB_SCENE_GRAPH_EXPORT
+#   define LIB_SCENE_GRAPH_EXPORT
+#  endif // LIB_SCENE_GRAPH_EXPORT
+
+#  ifndef LIB_WINGED_EDGE_EXPORT
+#   define LIB_WINGED_EDGE_EXPORT
+#  endif // LIB_WINGED_EDGE_EXPORT
+
+#  ifndef LIB_VIEW_MAP_EXPORT
+#   define LIB_VIEW_MAP_EXPORT
+#  endif // LIB_VIEW_MAP_EXPORT
+
+#  ifndef LIB_STROKE_EXPORT
+#   define LIB_STROKE_EXPORT
+#  endif // LIB_STROKE_EXPORT
+
+#  ifndef LIB_RENDERING_EXPORT
+#   define LIB_RENDERING_EXPORT
+#  endif // LIB_RENDERING_EXPORT
+
+#  ifndef LIB_WRAPPER_EXPORT
+#   define LIB_WRAPPER_EXPORT
+#  endif // LIB_WRAPPER_EXPORT
+
+# endif // WIN32
+
+} // end of namespace Config
+
+#endif // CONFIG_H
diff --git a/source/blender/freestyle/intern/system/Id.h b/source/blender/freestyle/intern/system/Id.h
new file mode 100755
index 00000000000..1f2206ed337
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Id.h
@@ -0,0 +1,126 @@
+//
+//  Filename         : Id.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Identification system
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  ID_H
+# define ID_H
+
+/*! Class used to tag any object by an id .
+ *  It is made of two unsigned integers.
+ */
+class Id
+{
+public:
+
+  typedef unsigned id_type;
+
+  /*! Default constructor */
+  Id() {
+    _first = 0;
+    _second = 0;
+  }
+
+  /*! Builds an Id from an integer.
+   *  The second number is set to 0.
+   */
+  Id(id_type id) {
+    _first = id;
+    _second = 0;
+  }
+
+  /*! Builds the Id from the two numbers */
+  Id(id_type ifirst, id_type isecond) {
+    _first = ifirst;
+    _second = isecond;
+  }
+
+  /*! Copy constructor */
+  Id(const Id& iBrother) {
+    _first = iBrother._first;
+    _second = iBrother._second;
+  }
+
+  /*! Operator= */
+  Id& operator=(const Id& iBrother) {
+   _first = iBrother._first;
+   _second = iBrother._second;
+    return *this;
+  } 
+
+  /*! Returns the first Id number */
+  id_type getFirst() const {
+    return _first;
+  }
+
+  /*! Returns the second Id number */
+  id_type getSecond() const {
+    return _second;
+  }
+
+  /*! Sets the first number constituing the Id */
+  void setFirst(id_type first) {
+    _first = first;
+  }
+
+  /*! Sets the second number constituing the Id */
+  void setSecond(id_type second) {
+    _second = second;
+  }
+  
+  /*! Operator== */
+  bool operator==(const Id& id) const {
+    return ((_first == id._first) && (_second == id._second));
+  }
+
+  /*! Operator!= */
+  bool operator!=(const Id& id) const {
+    return !((*this)==id);
+  }
+  
+  /*! Operator< */
+  bool operator<(const Id& id) const {
+    if (_first < id._first)
+      return true;
+    if (_first == id._first && _second < id._second)
+      return true;
+    return false;
+}
+
+private:
+
+  id_type _first;
+  id_type _second;
+};
+
+// stream operator
+inline std::ostream& operator<<(std::ostream& s, const Id& id) {
+  s << "[" << id.getFirst() << ", " << id.getSecond() << "]";
+  return s;
+}
+
+# endif // ID_H
diff --git a/source/blender/freestyle/intern/system/Interpreter.h b/source/blender/freestyle/intern/system/Interpreter.h
new file mode 100755
index 00000000000..45cb7793cfd
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Interpreter.h
@@ -0,0 +1,58 @@
+//
+//  Filename         : Interpreter.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Base Class of all script interpreters
+//  Date of creation : 17/04/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  INTERPRETER_H
+# define INTERPRETER_H
+
+# include <string>
+
+using namespace std;
+
+class LIB_SYSTEM_EXPORT Interpreter
+{
+ public:
+
+  Interpreter() { _language = "Unknown"; }
+
+  virtual ~Interpreter() {}; //soc
+
+  virtual int interpretCmd(const string& cmd) = 0;
+
+  virtual int interpretFile(const string& filename) = 0;
+
+  virtual string getLanguage() const { return _language; }
+
+  virtual void reset() = 0;
+
+ protected:
+
+  string _language;
+};
+
+#endif // INTERPRETER_H
diff --git a/source/blender/freestyle/intern/system/Precision.h b/source/blender/freestyle/intern/system/Precision.h
new file mode 100755
index 00000000000..24327a280df
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Precision.h
@@ -0,0 +1,39 @@
+//
+//  Filename         : Precision.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Define the float precision used in the program
+//  Date of creation : 30/07/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PRECISION_H
+# define PRECISION_H
+
+typedef double real;
+
+# ifndef SWIG
+static const real M_EPSILON  = 0.00000001;
+# endif // SWIG
+
+#endif // PRECISION_H
diff --git a/source/blender/freestyle/intern/system/ProgressBar.h b/source/blender/freestyle/intern/system/ProgressBar.h
new file mode 100755
index 00000000000..5b61f936c90
--- /dev/null
+++ b/source/blender/freestyle/intern/system/ProgressBar.h
@@ -0,0 +1,85 @@
+//
+//  Filename         : ProgressBar.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to encapsulate a progress bar
+//  Date of creation : 27/08/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PROGRESSBAR_H
+# define PROGRESSBAR_H
+
+# include <string>
+
+using namespace std;
+
+class ProgressBar
+{
+public:
+
+  inline ProgressBar() {
+    _numtotalsteps = 0;
+    _progress = 0;
+  }
+
+  virtual ~ProgressBar() {}
+
+  virtual void reset() {
+    _numtotalsteps = 0;
+    _progress = 0;
+  }
+
+  virtual void setTotalSteps(unsigned n) {
+    _numtotalsteps = n;
+  }
+
+  virtual void setProgress(unsigned i) {
+    _progress = i;
+  }
+
+  virtual void setLabelText(const string& s) {
+    _label = s;
+  }
+
+  /*! accessors */
+  inline unsigned int getTotalSteps() const {
+    return _numtotalsteps;
+  }
+
+  inline unsigned int getProgress() const {
+    return _progress;
+  }
+
+  inline string getLabelText() const {
+    return _label;
+  }
+ 
+protected:
+
+  unsigned _numtotalsteps;
+  unsigned _progress;
+  string _label;
+};
+
+#endif // PROGRESSBAR_H
diff --git a/source/blender/freestyle/intern/system/PseudoNoise.cpp b/source/blender/freestyle/intern/system/PseudoNoise.cpp
new file mode 100755
index 00000000000..87ee45e69b2
--- /dev/null
+++ b/source/blender/freestyle/intern/system/PseudoNoise.cpp
@@ -0,0 +1,108 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <math.h>
+#include "RandGen.h"
+#include "PseudoNoise.h"
+
+static const unsigned NB_VALUE_NOISE = 512;
+
+real *PseudoNoise::_values;
+
+PseudoNoise::PseudoNoise ()
+{
+}
+
+void
+PseudoNoise::init (long seed)
+{
+  _values = new real[NB_VALUE_NOISE];
+  RandGen::srand48(seed);
+  for (unsigned int i=0; i<NB_VALUE_NOISE; i++)
+    _values[i] = -1.0 + 2.0 * RandGen::drand48();
+}
+
+real 
+PseudoNoise::linearNoise (real x)
+{
+  int i = x*NB_VALUE_NOISE;
+  real x1=_values[i%NB_VALUE_NOISE], x2=_values[(i+1)%NB_VALUE_NOISE];
+  real t=x*real(NB_VALUE_NOISE)-real(i);
+  return x1*(1-t)+x2*t;
+}
+
+real 
+LanczosWindowed(real t)
+{
+  if (fabs(t)>2) return 0;
+  if (fabs(t)<M_EPSILON) return 1.0;
+  return sin(M_PI*t)/(M_PI*t) * sin(M_PI*t/2.0)/(M_PI*t/2.0);
+}
+
+real 
+PseudoNoise::smoothNoise (real x)
+{
+  int i = x*NB_VALUE_NOISE;
+  real t=x*real(NB_VALUE_NOISE)-real(i);
+  if (i - 1 < 0)
+    {
+      int plus=-i/NB_VALUE_NOISE;
+      i=i+NB_VALUE_NOISE*(plus+2);
+      t=(x+plus+2)*real(NB_VALUE_NOISE)-real(i);
+    }
+
+  real x1=_values[i%NB_VALUE_NOISE], x2=_values[(i+1)%NB_VALUE_NOISE];
+  real x0=_values[(i-1)%NB_VALUE_NOISE], x3=_values[(i+2)%NB_VALUE_NOISE];
+
+  real y0=LanczosWindowed(-1-t);
+  real y1=LanczosWindowed(-t);
+  real y2=LanczosWindowed(1-t);
+  real y3=LanczosWindowed(2-t);
+  //	cerr<<"x0="<<x0<<"  x1="<<x1<<"  x2="<<x2<<"  x3="<<x3<<endl;
+  //	cerr<<"y0="<<y0<<"  y1="<<y1<<"  y2="<<y2<<"  y3="<<y3<<"  :";
+  return (x0*y0+x1*y1+x2*y2+x3*y3)/(y0+y1+y2+y3);
+}
+
+real 
+PseudoNoise::turbulenceSmooth (real x, unsigned nbOctave)
+{
+  real y=0;
+  real k=1.0;
+  for (unsigned i=0; i<nbOctave; i++)
+    {
+      y=y+k*smoothNoise(x*k);
+      k=k/2.0;
+    }
+  return y;
+}
+
+real 
+PseudoNoise::turbulenceLinear (real x, unsigned nbOctave)
+{
+  real y=0;
+  real k=1.0;
+  for (unsigned i=0; i<nbOctave; i++)
+    {
+      y=y+k*linearNoise(x*k);
+      k=k/2.0;
+    }
+  return y;
+}
diff --git a/source/blender/freestyle/intern/system/PseudoNoise.h b/source/blender/freestyle/intern/system/PseudoNoise.h
new file mode 100755
index 00000000000..43143865600
--- /dev/null
+++ b/source/blender/freestyle/intern/system/PseudoNoise.h
@@ -0,0 +1,58 @@
+//
+//  Filename         : PseudoNoise.h
+//  Author(s)        : Fredo Durand
+//  Purpose          : Class to define a pseudo Perlin noise
+//  Date of creation : 16/06/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PSEUDONOISE_H
+# define PSEUDONOISE_H
+
+# include "FreestyleConfig.h"
+# include "Precision.h"
+
+class LIB_SYSTEM_EXPORT PseudoNoise 
+{
+public:
+
+  PseudoNoise ();
+
+  virtual ~PseudoNoise () {}
+	
+  real smoothNoise (real x);
+  real linearNoise (real x);
+
+  real turbulenceSmooth (real x, unsigned nbOctave = 8);
+  real turbulenceLinear (real x, unsigned nbOctave = 8);
+
+  static void init (long seed);
+
+protected:
+
+  static real *_values;
+};
+
+#endif // PSEUDONOISE_H
+
diff --git a/source/blender/freestyle/intern/system/PythonInterpreter.cpp b/source/blender/freestyle/intern/system/PythonInterpreter.cpp
new file mode 100755
index 00000000000..821bd32b40b
--- /dev/null
+++ b/source/blender/freestyle/intern/system/PythonInterpreter.cpp
@@ -0,0 +1,25 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "PythonInterpreter.h"
+
+string	PythonInterpreter::_path = "";
+bool	PythonInterpreter::_initialized = false;
diff --git a/source/blender/freestyle/intern/system/PythonInterpreter.h b/source/blender/freestyle/intern/system/PythonInterpreter.h
new file mode 100755
index 00000000000..719b777f38d
--- /dev/null
+++ b/source/blender/freestyle/intern/system/PythonInterpreter.h
@@ -0,0 +1,133 @@
+//
+//  Filename         : PythonInterpreter.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Python Interpreter
+//  Date of creation : 17/04/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  PYTHON_INTERPRETER_H
+# define PYTHON_INTERPRETER_H
+
+# include <iostream>
+# include <Python.h>
+# include "StringUtils.h"
+# include "Interpreter.h"
+
+//soc
+extern "C" {
+#include "BKE_text.h"
+#include "BPY_extern.h"
+}
+
+class LIB_SYSTEM_EXPORT PythonInterpreter : public Interpreter
+{
+ public:
+
+  PythonInterpreter() {
+    _language = "Python";
+    //Py_Initialize();
+  }
+
+  virtual ~PythonInterpreter() {
+    //Py_Finalize();
+  }
+
+  int interpretCmd(const string& cmd) {
+    initPath();
+    char* c_cmd = strdup(cmd.c_str());
+    int err = PyRun_SimpleString(c_cmd);
+    free(c_cmd);
+    return err;
+  }
+
+  int interpretFile(const string& filename) {
+    initPath();
+
+	char *fn = const_cast<char*>(filename.c_str());
+	struct Text *text = add_text( fn );
+	
+	if (text == NULL) {
+		cout << "\nError in PythonInterpreter::interpretFile:" << endl;
+		cout << "couldn't create Blender text from" << fn << endl;
+	}
+
+	if (BPY_txt_do_python_Text(text) != 1) {
+		cout << "\nError executing Python script from PythonInterpreter::interpretFile:" << endl;
+		cout << fn << " (at line " <<  BPY_Err_getLinenumber() << ")" << endl;
+		return BPY_Err_getLinenumber();
+	}
+
+	return 0;
+  }
+
+  struct Options
+  {
+    static void setPythonPath(const string& path) {
+      _path = path;
+    }
+
+    static string getPythonPath() {
+      return _path;
+    }
+  };
+
+  void reset() {
+    Py_Finalize();
+    Py_Initialize();
+    _initialized = false;
+  }
+
+private:
+
+  static void initPath() {
+	if (_initialized)
+		return;
+
+	vector<string> pathnames;
+	StringUtils::getPathName(_path, "", pathnames);
+	
+	struct Text *text = add_empty_text("tmp_initpath.txt");
+	string cmd = "import sys\n";
+	txt_insert_buf(text, const_cast<char*>(cmd.c_str()));
+	
+	for (vector<string>::const_iterator it = pathnames.begin(); it != pathnames.end();++it) {
+		if ( !it->empty() ) {
+			cout << "Adding Python path: " << *it << endl;
+			cmd = "sys.path.append(\"" + *it + "\")\n";
+			txt_insert_buf(text, const_cast<char*>(cmd.c_str()));
+		}
+	}
+	
+	BPY_txt_do_python_Text(text);
+	
+	//PyRun_SimpleString("from Freestyle import *");
+    _initialized = true;
+  }
+
+  static bool	_initialized;
+  static string _path;
+};
+
+#endif // PYTHON_INTERPRETER_H
diff --git a/source/blender/freestyle/intern/system/RandGen.cpp b/source/blender/freestyle/intern/system/RandGen.cpp
new file mode 100755
index 00000000000..a328cb7f583
--- /dev/null
+++ b/source/blender/freestyle/intern/system/RandGen.cpp
@@ -0,0 +1,86 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "RandGen.h"
+
+//
+// Macro definitions
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N	16
+#define MASK	((unsigned)(1 << (N - 1)) + (1 << (N - 1)) - 1)
+#define X0	0x330E
+#define X1	0xABCD
+#define X2	0x1234
+#define A0	0xE66D
+#define A1	0xDEEC
+#define A2	0x5
+#define C	0xB
+#define HI_BIT	(1L << (2 * N - 1))
+
+#define LOW(x)	((unsigned)(x) & MASK)
+#define HIGH(x)	LOW((x) >> N)
+#define MUL(x, y, z)	{ long l = (long)(x) * (long)(y); \
+		(z)[0] = LOW(l); (z)[1] = HIGH(l); }
+#define CARRY(x, y)	((unsigned long)((long)(x) + (long)(y)) > MASK)
+#define ADDEQU(x, y, z)	(z = CARRY(x, (y)), x = LOW(x + (y)))
+#define SET3(x, x0, x1, x2)	((x)[0] = (x0), (x)[1] = (x1), (x)[2] = (x2))
+#define SETLOW(x, y, n) SET3(x, LOW((y)[n]), LOW((y)[(n)+1]), LOW((y)[(n)+2]))
+#define SEED(x0, x1, x2) (SET3(x, x0, x1, x2), SET3(a, A0, A1, A2), c = C)
+#define REST(v)	for (i = 0; i < 3; i++) { xsubi[i] = x[i]; x[i] = temp[i]; } \
+		return (v);
+#define NEST(TYPE, f, F)	TYPE f(register unsigned short *xsubi) { \
+	register int i; register TYPE v; unsigned temp[3]; \
+	for (i = 0; i < 3; i++) { temp[i] = x[i]; x[i] = LOW(xsubi[i]); }  \
+	v = F(); REST(v); }
+
+static unsigned x[3] = { X0, X1, X2 }, a[3] = { A0, A1, A2 }, c = C;
+
+//
+// Methods implementation
+//
+///////////////////////////////////////////////////////////////////////////////
+
+real RandGen::drand48() {
+  static real two16m = 1.0 / (1L << N);
+  next();
+  return (two16m * (two16m * (two16m * x[0] + x[1]) + x[2]));
+}
+
+void RandGen::srand48(long seedval) {
+  SEED(X0, LOW(seedval), HIGH(seedval));
+}
+
+void RandGen::next() {
+  unsigned p[2], q[2], r[2], carry0, carry1;
+  
+  MUL(a[0], x[0], p);
+  ADDEQU(p[0], c, carry0);
+  ADDEQU(p[1], carry0, carry1);
+  MUL(a[0], x[1], q);
+  ADDEQU(p[1], q[0], carry0);
+  MUL(a[1], x[0], r);
+  x[2] = LOW(carry0 + carry1 + CARRY(p[1], r[0]) + q[1] + r[1] +
+	     a[0] * x[2] + a[1] * x[1] + a[2] * x[0]);
+  x[1] = LOW(p[1] + r[0]);
+  x[0] = LOW(p[0]);
+}
diff --git a/source/blender/freestyle/intern/system/RandGen.h b/source/blender/freestyle/intern/system/RandGen.h
new file mode 100755
index 00000000000..409d3b79609
--- /dev/null
+++ b/source/blender/freestyle/intern/system/RandGen.h
@@ -0,0 +1,48 @@
+//
+//  Filename         : RandGen.h
+//  Author(s)        : Fredo Durand
+//  Purpose          : Pseudo-random number generator
+//  Date of creation : 20/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  RAND_GEN_H
+# define RAND_GEN_H
+
+# include "FreestyleConfig.h"
+# include "../system/Precision.h"
+
+class LIB_SYSTEM_EXPORT RandGen
+{
+public:
+
+  static real	drand48();
+  static void	srand48(long value);
+
+private:
+
+  static void	next();
+};
+
+#endif // RAND_GEN_H
diff --git a/source/blender/freestyle/intern/system/StringUtils.cpp b/source/blender/freestyle/intern/system/StringUtils.cpp
new file mode 100755
index 00000000000..58798daf42a
--- /dev/null
+++ b/source/blender/freestyle/intern/system/StringUtils.cpp
@@ -0,0 +1,74 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//soc #include <qfileinfo.h>
+#include "FreestyleConfig.h"
+#include "StringUtils.h"
+
+namespace StringUtils {
+
+  void getPathName(const string& path, const string& base, vector<string>& pathnames) {
+    string dir;
+	string res;
+	char cleaned[FILE_MAX];
+    unsigned size = path.size();
+
+    pathnames.push_back(base);
+
+    for (	unsigned pos = 0, sep = path.find(Config::PATH_SEP, pos);
+			pos < size;
+	 		pos = sep + 1, sep = path.find(Config::PATH_SEP, pos)) {
+
+		if (sep == (unsigned)string::npos)
+			sep = size;
+		
+		dir = path.substr(pos, sep - pos);
+
+		BLI_strncpy(cleaned, dir.c_str(), FILE_MAX);
+		BLI_cleanup_file(NULL, cleaned);
+		res = toAscii( string(cleaned) );
+	
+		if (!base.empty())
+			res += Config::DIR_SEP + base;
+		
+		pathnames.push_back(res);
+    }
+  }
+
+	string toAscii( const string &str ){
+		stringstream out("");
+		char s;
+		
+		for(unsigned int i=0; i < str.size() ; i++){
+			s =  ((char)(str.at(i) & 0x7F));
+			out << s;
+		}	
+		
+		return out.str();
+	}
+	
+	const char* toAscii( const char *str ){
+		return toAscii(string(str)).c_str();
+	}
+
+  
+
+} // end of namespace StringUtils
diff --git a/source/blender/freestyle/intern/system/StringUtils.h b/source/blender/freestyle/intern/system/StringUtils.h
new file mode 100755
index 00000000000..7b43886fa27
--- /dev/null
+++ b/source/blender/freestyle/intern/system/StringUtils.h
@@ -0,0 +1,61 @@
+//
+//  Filename         : StringUtils.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : String utilities
+//  Date of creation : 20/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  STRING_UTILS_H
+# define STRING_UTILS_H
+
+# include <vector>
+# include <string>
+# include <sstream>
+# include <iostream>
+# include "FreestyleConfig.h"
+
+//soc
+extern "C" {
+#include "BKE_utildefines.h"
+#include "BLI_blenlib.h"
+}
+
+using namespace std;
+
+namespace StringUtils {
+
+  LIB_SYSTEM_EXPORT 
+  void getPathName(const string& path, const string& base, vector<string>& pathnames);
+  string toAscii( const string &str );
+  const char* toAscii( const char *str );
+
+  // STL related
+  struct ltstr{
+  bool operator()(const char* s1, const char* s2) const{
+    return strcmp(s1, s2) < 0;
+  }
+};
+
+} // end of namespace StringUtils
+
+#endif // STRING_UTILS_H
diff --git a/source/blender/freestyle/intern/system/TimeStamp.cpp b/source/blender/freestyle/intern/system/TimeStamp.cpp
new file mode 100755
index 00000000000..c66e1131611
--- /dev/null
+++ b/source/blender/freestyle/intern/system/TimeStamp.cpp
@@ -0,0 +1,25 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "TimeStamp.h"
+
+LIB_SYSTEM_EXPORT 
+TimeStamp* TimeStamp::_instance = 0;
diff --git a/source/blender/freestyle/intern/system/TimeStamp.h b/source/blender/freestyle/intern/system/TimeStamp.h
new file mode 100755
index 00000000000..568a7851e30
--- /dev/null
+++ b/source/blender/freestyle/intern/system/TimeStamp.h
@@ -0,0 +1,71 @@
+//
+//  Filename         : TimeStamp.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class defining a singleton used as timestamp
+//  Date of creation : 12/12/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  TIMESTAMP_H
+# define TIMESTAMP_H
+
+# include "FreestyleConfig.h"
+
+class LIB_SYSTEM_EXPORT TimeStamp 
+{
+ public:
+
+  static inline TimeStamp* instance() {
+    if (_instance == 0)
+      _instance = new TimeStamp;
+    return _instance;
+  }
+
+  inline unsigned getTimeStamp() const {
+    return _time_stamp;
+  }
+
+  inline void increment() {
+    ++_time_stamp;
+  }
+
+  inline void reset() {
+    _time_stamp = 1;
+  }
+
+ protected:
+  
+  TimeStamp() {
+    _time_stamp = 1;
+  }
+
+  TimeStamp(const TimeStamp&) {}
+
+ private:
+
+  static TimeStamp* _instance;
+  unsigned _time_stamp;
+};
+
+#endif // TIMESTAMP_H
diff --git a/source/blender/freestyle/intern/system/TimeUtils.h b/source/blender/freestyle/intern/system/TimeUtils.h
new file mode 100755
index 00000000000..99dd5b0a669
--- /dev/null
+++ b/source/blender/freestyle/intern/system/TimeUtils.h
@@ -0,0 +1,58 @@
+//
+//  Filename         : TimeUtils.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to measure ellapsed time
+//  Date of creation : 10/04/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  TIMEUTILS_H
+# define TIMEUTILS_H
+
+#include <time.h>
+#include "FreestyleConfig.h"
+
+class Chronometer 
+{
+ public:
+
+  inline Chronometer() {}
+  inline ~Chronometer() {}
+
+  inline clock_t start() {
+    _start = clock();
+    return _start;
+  }
+
+  inline double stop() {
+    clock_t stop = clock();
+    return (double)(stop - _start) / CLOCKS_PER_SEC ;
+  }
+
+ private:
+
+  clock_t _start;
+};
+
+#endif // TIMEUTILS_H
diff --git a/source/blender/freestyle/intern/system/src.pri b/source/blender/freestyle/intern/system/src.pri
new file mode 100755
index 00000000000..e7d69e142b4
--- /dev/null
+++ b/source/blender/freestyle/intern/system/src.pri
@@ -0,0 +1,30 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+SYSTEM_DIR = ../system
+
+SOURCES *= $${SYSTEM_DIR}/Exception.cpp \
+	   $${SYSTEM_DIR}/PythonInterpreter.cpp \
+	   $${SYSTEM_DIR}/RandGen.cpp \
+	   $${SYSTEM_DIR}/StringUtils.cpp \
+	   $${SYSTEM_DIR}/TimeStamp.cpp \
+	   $${SYSTEM_DIR}/PseudoNoise.cpp \
+           $${SYSTEM_DIR}/BaseObject.cpp
+
+HEADERS *= $${SYSTEM_DIR}/BaseObject.h \
+	   $${SYSTEM_DIR}/BaseIterator.h \
+	   $${SYSTEM_DIR}/Cast.h \
+	   $${SYSTEM_DIR}/FreestyleConfig.h \
+	   $${SYSTEM_DIR}/Exception.h \
+	   $${SYSTEM_DIR}/Id.h \
+	   $${SYSTEM_DIR}/Interpreter.h \
+	   $${SYSTEM_DIR}/ProgressBar.h \
+	   $${SYSTEM_DIR}/PythonInterpreter.h \
+	   $${SYSTEM_DIR}/RandGen.h \
+	   $${SYSTEM_DIR}/StringUtils.h \
+	   $${SYSTEM_DIR}/TimeStamp.h \
+	   $${SYSTEM_DIR}/TimeUtils.h \
+	   $${SYSTEM_DIR}/PseudoNoise.h \
+	   $${SYSTEM_DIR}/Precision.h
diff --git a/source/blender/freestyle/intern/system/system.pro b/source/blender/freestyle/intern/system/system.pro
new file mode 100755
index 00000000000..495cdf47105
--- /dev/null
+++ b/source/blender/freestyle/intern/system/system.pro
@@ -0,0 +1,73 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+FOO_LIB_VERSION	= $${APPVERSION_MAJ}$${APPVERSION_MID}
+TEMPLATE        = lib
+TARGET          = $${LIB_SYSTEM}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll python$${PYTHON_VERSION_MAJ}.$${PYTHON_VERSION_MIN}
+QT += xml
+
+exists (../libconfig.pri) {
+  include (../libconfig.pri)
+}
+#
+# INCLUDE PATH
+#
+#######################################
+
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES   *= MAKE_LIB_SYSTEM_DLL
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build/
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#win32:QMAKE_POST_LINK = "$$QMAKE_MOVE $${DESTDIR}/$${TARGET}$${LIBVERSION}.lib $${DESTDIR}\$${TARGET}$${FOO_LIB_VERSION}.lib"
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
+
diff --git a/source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp b/source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
new file mode 100755
index 00000000000..54a982b8bd8
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
@@ -0,0 +1,678 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "FEdgeXDetector.h"
+#include "float.h"
+#include "../geometry/GeomUtils.h"
+#include <math.h>
+#include "../geometry/normal_cycle.h"
+
+void FEdgeXDetector::processShapes(WingedEdge& we) {
+  bool progressBarDisplay = false;
+  Vec3r Min, Max;
+  vector<WShape*> wshapes = we.getWShapes();
+  WXShape * wxs;
+
+  if(_pProgressBar != NULL) {
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Detecting feature lines");
+    _pProgressBar->setTotalSteps(wshapes.size() * 3);
+    _pProgressBar->setProgress(0);
+    progressBarDisplay = true;
+  }
+
+  for(vector<WShape*>::const_iterator it = wshapes.begin();
+  it != wshapes.end();
+  it++){
+    wxs = dynamic_cast<WXShape*>(*it);
+    wxs->bbox(Min, Max);
+    _bbox_diagonal = (Max-Min).norm();
+    if(_changes){
+      vector<WFace*>& wfaces = wxs->GetFaceList();
+      for(vector<WFace*>::iterator wf=wfaces.begin(), wfend=wfaces.end();
+      wf!=wfend;
+      ++wf){
+        WXFace* wxf = dynamic_cast<WXFace*>(*wf);
+        wxf->Clear();
+      }
+      _computeViewIndependant = true;
+    } else if (!(wxs)->getComputeViewIndependantFlag()) {
+      wxs->Reset();
+      _computeViewIndependant = false;
+    } else {
+      _computeViewIndependant = true;
+    }
+    preProcessShape(wxs);
+    if (progressBarDisplay)
+      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+    processBorderShape(wxs);
+    processCreaseShape(wxs);
+    if(_computeRidgesAndValleys)
+      processRidgesAndValleysShape(wxs);
+    if(_computeSuggestiveContours)
+      processSuggestiveContourShape(wxs);
+    processSilhouetteShape(wxs);
+    if (progressBarDisplay)
+      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+
+    // build smooth edges:
+    buildSmoothEdges(wxs);
+
+    // Post processing for suggestive contours
+    if(_computeSuggestiveContours)
+      postProcessSuggestiveContourShape(wxs);
+    if (progressBarDisplay)
+      _pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+
+    wxs->setComputeViewIndependantFlag(false);
+    _computeViewIndependant = false;
+    _changes = false;
+
+    // reset user data
+    (*it)->ResetUserData();
+  }
+}
+
+// GENERAL STUFF
+////////////////
+void FEdgeXDetector::preProcessShape(WXShape* iWShape) {
+  _meanK1 = 0;
+  _meanKr = 0;
+  _minK1 = FLT_MAX;
+  _maxK1 = -FLT_MAX;
+  _minKr = FLT_MAX;
+  _maxKr = -FLT_MAX;
+  _nPoints = 0;
+  _meanEdgeSize = iWShape->getMeanEdgeSize();
+  
+  vector<WFace*>& wfaces = iWShape->GetFaceList();
+  vector<WFace*>::iterator f,fend;
+  // view dependant stuff
+  for(f=wfaces.begin(), fend=wfaces.end();
+  f!=fend;
+  ++f){
+    preProcessFace((WXFace*)(*f));
+  }
+
+  vector<WVertex*>& wvertices = iWShape->GetVertexList();
+  for(vector<WVertex*>::iterator wv=wvertices.begin(), wvend=wvertices.end(); 
+  wv!=wvend;
+  ++wv){
+    // Compute curvatures
+    WXVertex * wxv = dynamic_cast<WXVertex*>(*wv);
+    computeCurvatures(wxv);
+  }
+  _meanK1 /= (real)(_nPoints);
+  _meanKr /= (real)(_nPoints);
+}
+
+void FEdgeXDetector::preProcessFace(WXFace *iFace){
+  Vec3r firstPoint = iFace->GetVertex(0)->GetVertex();
+  Vec3r N = iFace->GetNormal();
+
+  // Compute the dot product between V (=_Viewpoint - firstPoint) and N:
+  Vec3r V(_Viewpoint - firstPoint);
+  N.normalize();
+  V.normalize();
+  iFace->setDotP(N * V);
+  
+  // compute the distance between the face center and the viewpoint:
+  Vec3r dist_vec(iFace->center() - _Viewpoint);
+  iFace->setZ(dist_vec.norm());
+}
+
+void FEdgeXDetector::computeCurvatures(WXVertex *vertex){
+   // CURVATURE LAYER
+  // store all the curvature datas for each vertex
+
+  //soc unused - real K1, K2
+  real cos2theta, sin2theta;
+  Vec3r e1, n, v;
+  // one vertex curvature info :
+  CurvatureInfo *C;
+  float radius = _sphereRadius*_meanEdgeSize; 
+  
+  // view independant stuff
+  if(_computeViewIndependant){
+    C = new CurvatureInfo();   
+    vertex->setCurvatures(C);
+    OGF::NormalCycle ncycle ;
+    ncycle.begin() ;
+    if(radius > 0) {
+      OGF::compute_curvature_tensor(vertex, radius, ncycle) ;
+    } else {
+      OGF::compute_curvature_tensor_one_ring(vertex, ncycle) ;
+    }
+    ncycle.end() ;
+    C->K1 = ncycle.kmin();
+    C->K2 = ncycle.kmax();
+    C->e1 = ncycle.Kmax(); //ncycle.kmin() * ncycle.Kmax();
+    C->e2 = ncycle.Kmin(); //ncycle.kmax() * ncycle.Kmin() ;
+
+    real absK1 = fabs(C->K1);
+    _meanK1 += absK1;
+    if(absK1 > _maxK1)
+      _maxK1 = absK1;
+    if(absK1 < _minK1)
+      _minK1 = absK1;
+  }
+  // view dependant
+  C = vertex->curvatures();
+  if(C == 0)
+    return;
+    
+  // compute radial curvature :
+  n = C->e1 ^ C->e2;
+  v = _Viewpoint - vertex->GetVertex();
+  C->er = v - (v * n) * n;
+  C->er.normalize();
+  e1 = C->e1;
+  e1.normalize();
+  cos2theta = C->er * e1;
+  cos2theta *= cos2theta;
+  sin2theta = 1 - cos2theta;
+  C->Kr = C->K1 * cos2theta + C->K2 * sin2theta;
+  real absKr = fabs(C->Kr);
+  _meanKr += absKr;
+  if(absKr > _maxKr)
+    _maxKr = absKr;
+  if(absKr < _minKr)
+    _minKr = absKr;
+
+  ++_nPoints;
+}
+
+// SILHOUETTE
+/////////////
+void FEdgeXDetector::processSilhouetteShape(WXShape* iWShape) {
+  // Make a first pass on every polygons in order 
+  // to compute all their silhouette relative values:
+  //------------------------------------------------
+  vector<WFace*>& wfaces = iWShape->GetFaceList();
+  vector<WFace*>::iterator f,fend;
+  for(f=wfaces.begin(), fend=wfaces.end();
+  f!=fend;
+  ++f)
+  {
+    ProcessSilhouetteFace((WXFace*)(*f));
+  }
+
+  // Make a pass on the edges to detect 
+  // the silhouette edges that are not smooth
+  // --------------------
+  vector<WEdge*>::iterator we, weend;
+  vector<WEdge*> &wedges = iWShape->GetEdgeList();
+  for(we=wedges.begin(), weend=wedges.end();
+  we!=weend;
+  ++we)
+  {
+    ProcessSilhouetteEdge((WXEdge*)(*we));
+  }
+}
+
+void FEdgeXDetector::ProcessSilhouetteFace(WXFace *iFace)
+{
+  
+  // SILHOUETTE LAYER
+  Vec3r normal;
+  // Compute the dot products between View direction and N at each vertex
+  // of the face:
+  Vec3r point;
+  int closestPointId = 0;
+  real dist, minDist = FLT_MAX;
+  int numVertices = iFace->numberOfVertices();
+  WXFaceLayer * faceLayer = new WXFaceLayer(iFace, Nature::SILHOUETTE, true);
+  for(int i=0; i<numVertices; i++){
+    point = iFace->GetVertex(i)->GetVertex();
+    normal = iFace->GetVertexNormal(i);
+    Vec3r V(_Viewpoint - point);
+    normal.normalize();
+    V.normalize();
+    real d = normal * V;
+    faceLayer->PushDotP(d);
+    // Find the point the closest to the viewpoint
+    Vec3r dist_vec(point - _Viewpoint);
+    dist = dist_vec.norm();
+    if(dist < minDist) {
+      minDist = dist;
+      closestPointId = i;
+    }
+  }
+  // Set the closest point id:
+  faceLayer->setClosestPointIndex(closestPointId);
+  // Add this layer to the face:
+  iFace->AddSmoothLayer(faceLayer);
+}
+
+void FEdgeXDetector::ProcessSilhouetteEdge(WXEdge *iEdge)
+{
+  if(iEdge->nature() & Nature::BORDER)
+    return;
+  // SILHOUETTE ?
+  //-------------
+  WXFace * fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
+  WXFace * fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
+
+  if((fA->front())^(fB->front())){ // fA->visible XOR fB->visible (true if one is 0 and the other is 1)
+    // The only edges we want to set as silhouette edges in this 
+    // way are the ones with 2 different normals for 1 vertex 
+    // for these two faces
+    //--------------------
+    // In reality we only test the normals for 1 of the 2 vertices.
+    if(fA->GetVertexNormal(iEdge->GetaVertex()) == fB->GetVertexNormal(iEdge->GetaVertex()))
+      return;
+    iEdge->AddNature(Nature::SILHOUETTE);
+    if(fB->front())
+      iEdge->setOrder(1);
+    else
+      iEdge->setOrder(-1);
+  }
+}
+
+
+// BORDER
+/////////
+void FEdgeXDetector::processBorderShape(WXShape* iWShape) {
+
+  if(!_computeViewIndependant)
+    return;
+  // Make a pass on the edges to detect 
+  // the BORDER
+  // --------------------
+  vector<WEdge*>::iterator we, weend;
+  vector<WEdge*> &wedges = iWShape->GetEdgeList();
+  for(we=wedges.begin(), weend=wedges.end();
+  we!=weend;
+  ++we){
+    ProcessBorderEdge((WXEdge*)(*we));
+  }
+}
+
+void FEdgeXDetector::ProcessBorderEdge(WXEdge *iEdge)
+{
+  // first check whether it is a border edge:
+  // BORDER ?
+  //---------
+  if(iEdge->GetaFace() == 0){
+    // it is a border edge
+    iEdge->AddNature(Nature::BORDER);
+  }
+}
+
+
+// CREASE
+/////////
+void FEdgeXDetector::processCreaseShape(WXShape* iWShape) {
+  if(!_computeViewIndependant)
+    return;
+
+  // Make a pass on the edges to detect 
+  // the CREASE 
+  // --------------------
+  vector<WEdge*>::iterator we, weend;
+  vector<WEdge*> &wedges = iWShape->GetEdgeList();
+  for(we=wedges.begin(), weend=wedges.end();
+  we!=weend;
+  ++we){
+    ProcessCreaseEdge((WXEdge*)(*we));
+  }
+}
+
+void FEdgeXDetector::ProcessCreaseEdge(WXEdge *iEdge)
+{
+  // CREASE ?
+  //---------
+  if(iEdge->nature() & Nature::BORDER)
+    return;
+  WXFace * fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
+  WXFace * fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
+
+  WVertex * aVertex = iEdge->GetaVertex();
+  if((fA->GetVertexNormal(aVertex) * fB->GetVertexNormal(aVertex)) <= 0.7) // angle of 140 degrees
+    iEdge->AddNature(Nature::CREASE);
+}
+
+// RIDGES AND VALLEYS
+/////////////////////
+
+void FEdgeXDetector::processRidgesAndValleysShape(WXShape* iWShape) {
+  // Don't forget to add the built layer to the face at the end
+  // of the ProcessFace:
+  //iFace->AddSmoothLayer(faceLayer);
+
+  if((!_computeViewIndependant))
+    return;
+  
+  // Here the curvatures must already have been computed
+  vector<WFace*>& wfaces = iWShape->GetFaceList();
+  vector<WFace*>::iterator f, fend;
+  for(f=wfaces.begin(), fend=wfaces.end();
+	f!=fend;
+	++f)
+  { 
+	ProcessRidgeFace((WXFace*)(*f));
+  }
+}
+
+
+// RIDGES
+/////////
+
+void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
+{
+  WXFaceLayer * flayer = new WXFaceLayer(iFace, Nature::RIDGE|Nature::VALLEY, false);
+  iFace->AddSmoothLayer(flayer);
+  
+  unsigned int numVertices = iFace->numberOfVertices();
+  for(unsigned int i=0; i<numVertices; ++i){
+    WVertex *wv = iFace->GetVertex(i);
+    WXVertex * wxv = dynamic_cast<WXVertex*>(wv);
+    flayer->PushDotP(wxv->curvatures()->K1);
+  }
+
+  real threshold = 0;
+  //real threshold = _maxK1 - (_maxK1-_meanK1)/20.0;
+  
+  if(flayer->nPosDotP()!=numVertices){
+    if((fabs(flayer->dotP(0)) < threshold) && (fabs(flayer->dotP(1)) < threshold) && (fabs(flayer->dotP(2)) < threshold)){
+      flayer->ReplaceDotP(0, 0);
+      flayer->ReplaceDotP(1, 0);
+      flayer->ReplaceDotP(2, 0);
+    }
+  }
+}
+
+// void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
+// {
+ 
+//  //  RIDGE LAYER
+//  //    compute the RidgeFunction, that is the derivative of the ppal curvature
+//  //    along e1 at each vertex of the face
+ 
+//  WVertex *v;
+//  Vec3r v1v2;
+//  real t;
+//  vector<WXFaceLayer*> SmoothLayers;
+//  WXFaceLayer *faceLayer;
+//  Face_Curvature_Info *layer_info;
+//  real K1_a(0), K1_b(0);
+//  Vec3r Inter_a, Inter_b;
+
+//  //  find the ridge layer of the face
+//  iFace->retrieveSmoothLayers(Nature::RIDGE, SmoothLayers);
+//  if(SmoothLayers.size()!=1)
+//    return;
+//  faceLayer = SmoothLayers[0];
+//  //  retrieve the curvature info of this layer
+//  layer_info = (Face_Curvature_Info *)faceLayer->userdata;
+ 
+//  int numVertices = iFace->numberOfVertices();
+//  for(int i=0; i<numVertices; i++){
+//    v = iFace->GetVertex(i);
+//    //    vec_curvature_info[i] contains the curvature info of this vertex
+//    Vec3r e2 = layer_info->vec_curvature_info[i]->K2*layer_info->vec_curvature_info[i]->e2;
+//    Vec3r e1 = layer_info->vec_curvature_info[i]->K1*layer_info->vec_curvature_info[i]->e1;
+//    e2.normalize();
+   
+//    WVertex::face_iterator fit = v->faces_begin();
+//    WVertex::face_iterator fitend = v->faces_end();
+//    for(; fit!=fitend; ++fit){  
+//      WXFace * wxf = dynamic_cast<WXFace*>(*fit);
+//      WOEdge * oppositeEdge;
+//      if(!(wxf->getOppositeEdge(v, oppositeEdge)))
+//        continue;
+//      v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
+//      GeomUtils::intersection_test res;
+//      res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2,
+//        e2, -(v->GetVertex()*e2),
+//        t,1.e-06);
+//      if((res == GeomUtils::DO_INTERSECT) && (t>=0.0) && (t<=1.0)){
+//        vector<WXFaceLayer*> second_ridge_layer;
+//        wxf->retrieveSmoothLayers(Nature::RIDGE, second_ridge_layer);
+//        if(second_ridge_layer.size()!=1)
+//          continue;
+//        Face_Curvature_Info *second_layer_info = (Face_Curvature_Info*)second_ridge_layer[0]->userdata;
+       
+//        unsigned index1 = wxf->GetIndex(oppositeEdge->GetaVertex());
+//        unsigned index2 = wxf->GetIndex(oppositeEdge->GetbVertex());
+//        real K1_1 = second_layer_info->vec_curvature_info[index1]->K1;
+//        real K1_2 = second_layer_info->vec_curvature_info[index2]->K1;
+//        real K1 = (1.0-t)*K1_1 + t*K1_2;
+//        Vec3r inter((1.0-t)*oppositeEdge->GetaVertex()->GetVertex() + t*oppositeEdge->GetbVertex()->GetVertex());
+//        Vec3r vtmp(inter - v->GetVertex());
+//        // is it K1_a or K1_b ?
+//        if(vtmp*e1 > 0){
+//          K1_b = K1;
+//          Inter_b = inter;
+//        }else{
+//          K1_a = K1;
+//          Inter_a = inter;
+//        }
+//      }  
+//    }  
+//    //    Once we have K1 along the the ppal direction
+//    //      compute the derivative : K1b - K1a
+//    //      put it in DotP
+//    //real d = fabs(K1_b)-fabs(K1_a);
+//    real d = 0;
+//    real threshold = _meanK1 + (_maxK1-_meanK1)/7.0;
+//    //real threshold = _meanK1;
+//    //if((fabs(K1_b) > threshold) || ((fabs(K1_a) > threshold)))
+//      d = (K1_b)-(K1_a)/(Inter_b-Inter_a).norm();
+//    faceLayer->PushDotP(d);
+//    //faceLayer->PushDotP(layer_info->vec_curvature_info[i]->K1);
+//  } 
+
+//  // Make the values relevant by checking whether all principal 
+//  // directions have the "same" direction:
+//  Vec3r e0((layer_info->vec_curvature_info[0]->K1*layer_info->vec_curvature_info[0]->e1));
+//  e0.normalize();
+//  Vec3r e1((layer_info->vec_curvature_info[1]->K1*layer_info->vec_curvature_info[1]->e1));
+//  e1.normalize();
+//  Vec3r e2((layer_info->vec_curvature_info[2]->K1*layer_info->vec_curvature_info[2]->e1));
+//  e2.normalize();
+//  if (e0 * e1 < 0)
+//    // invert dotP[1]
+//    faceLayer->ReplaceDotP(1, -faceLayer->dotP(1));
+//  if (e0 * e2 < 0)
+//    // invert dotP[2]
+//    faceLayer->ReplaceDotP(2, -faceLayer->dotP(2));
+
+//  // remove the weakest values;
+//  //real minDiff = (_maxK1 - _minK1)/10.0;
+//  //  real minDiff = _meanK1;
+//  //  if((faceLayer->dotP(0) < minDiff) && (faceLayer->dotP(1) < minDiff) && (faceLayer->dotP(2) < minDiff)){
+//  //    faceLayer->ReplaceDotP(0, 0);
+//  //    faceLayer->ReplaceDotP(1, 0);
+//  //    faceLayer->ReplaceDotP(2, 0);
+//  //  } 
+// }
+
+// SUGGESTIVE CONTOURS
+//////////////////////
+
+void FEdgeXDetector::processSuggestiveContourShape(WXShape* iWShape) {
+  
+  // Here the curvatures must already have been computed
+  vector<WFace*>& wfaces = iWShape->GetFaceList();
+  vector<WFace*>::iterator f, fend;
+  for(f=wfaces.begin(), fend=wfaces.end();
+	f!=fend;
+	++f)
+  {
+	  ProcessSuggestiveContourFace((WXFace*)(*f));
+  }
+}
+
+void FEdgeXDetector::ProcessSuggestiveContourFace(WXFace *iFace)
+{
+  WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SUGGESTIVE_CONTOUR, true);
+  iFace->AddSmoothLayer(faceLayer);
+
+  unsigned int numVertices = iFace->numberOfVertices();
+  for(unsigned int i=0; i<numVertices; ++i){
+    WVertex *wv = iFace->GetVertex(i);
+    WXVertex * wxv = dynamic_cast<WXVertex*>(wv);
+    faceLayer->PushDotP(wxv->curvatures()->Kr);
+  }
+  
+  // FIXME: find a more clever way to compute the threshold
+//   real threshold = _meanKr;
+//   if(faceLayer->nPosDotP()!=numVertices){
+//     if((fabs(faceLayer->dotP(0)) < threshold) && (fabs(faceLayer->dotP(1)) < threshold) && (fabs(faceLayer->dotP(2)) < threshold)){
+//       faceLayer->ReplaceDotP(0, 0);
+//       faceLayer->ReplaceDotP(1, 0);
+//       faceLayer->ReplaceDotP(2, 0);
+//     }
+//   }
+}
+
+void FEdgeXDetector::postProcessSuggestiveContourShape(WXShape* iShape) {
+  vector<WFace*>& wfaces = iShape->GetFaceList();
+  vector<WFace*>::iterator f, fend;
+  for(f=wfaces.begin(), fend=wfaces.end();
+      f!=fend;
+      ++f)
+    {
+      postProcessSuggestiveContourFace((WXFace*)(*f));
+    }
+}
+
+void FEdgeXDetector::postProcessSuggestiveContourFace(WXFace *iFace) {
+
+  // Compute the derivative of the radial curvature in the radial direction,
+  // at the two extremities of the smooth edge.
+  // If the derivative is smaller than a given threshold _kr_derivative_epsilon,
+  // discard the edge.
+ 
+  // Find the suggestive contour layer of the face (zero or one edge).
+  vector<WXFaceLayer*> sc_layers;
+  iFace->retrieveSmoothEdgesLayers(Nature::SUGGESTIVE_CONTOUR, sc_layers);
+  if(sc_layers.empty())
+    return;
+
+  WXFaceLayer *sc_layer;
+  sc_layer = sc_layers[0];
+
+  // Compute the derivative value at each vertex of the face, and add it in a vector.
+  vector<real> kr_derivatives;
+
+  unsigned vertices_nb = iFace->numberOfVertices();
+  WXVertex *v, *opposite_vertex_a, *opposite_vertex_b;
+  WXFace *wxf;
+  WOEdge *opposite_edge;
+  Vec3r opposite_edge_vec, normal_vec, radial_normal_vec, er_vec, v_vec, inter, inter1, inter2, tmp_vec;
+  GeomUtils::intersection_test res;
+  real kr(0), kr1(0), kr2(0), t;
+
+  for (unsigned i = 0; i < vertices_nb; ++i) {
+    v = (WXVertex*)(iFace->GetVertex(i));
+
+    // v is a singular vertex, skip it.
+    if (v->isBoundary()) {
+      kr_derivatives.push_back(0);
+      continue;
+    }
+
+    v_vec = v->GetVertex();
+    er_vec = v->curvatures()->er;
+    
+    // For each vertex, iterate on its adjacent faces.
+    for (WVertex::face_iterator fit = v->faces_begin(), fitend = v->faces_end();
+	 fit != fitend;
+	 ++fit) {  
+      wxf = dynamic_cast<WXFace*>(*fit);
+      if(!(wxf->getOppositeEdge(v, opposite_edge)))
+	continue;
+      
+      opposite_vertex_a = (WXVertex*)opposite_edge->GetaVertex();
+      opposite_vertex_b = (WXVertex*)opposite_edge->GetbVertex();
+      opposite_edge_vec = opposite_vertex_b->GetVertex() - opposite_vertex_a->GetVertex();
+      normal_vec = wxf->GetVertexNormal(v); // FIXME: what about e1 ^ e2 ?
+      radial_normal_vec = er_vec ^ normal_vec;
+
+      // Test wether the radial plan intersects with the edge at the opposite of v.
+      res = GeomUtils::intersectRayPlane(opposite_vertex_a->GetVertex(), opposite_edge_vec,
+					 radial_normal_vec, -(v_vec * radial_normal_vec),
+					 t,
+					 1.e-06);
+      
+      // If there is an intersection, compute the value of the derivative ath that point.
+      if ((res == GeomUtils::DO_INTERSECT) && (t >= 0) && (t <= 1)) {
+	kr = t * opposite_vertex_a->curvatures()->Kr + (1 - t) * opposite_vertex_b->curvatures()->Kr;
+	inter = opposite_vertex_a->GetVertex() + t * opposite_edge_vec;
+	tmp_vec = inter - v->GetVertex();
+	// Is it kr1 or kr2?
+	if (tmp_vec * er_vec > 0) {
+	  kr2 = kr;
+	  inter2 = inter;
+	} else {
+	  kr1 = kr;
+	  inter1 = inter;
+	}
+      }
+    }
+
+    // Now we have kr1 and kr2 along the radial direction, for one vertex of iFace.
+    // We have to compute the derivative of kr for that vertex, equal to:
+    // (kr2 - kr1) / dist(inter1, inter2).
+    // Then we add it to the vector of derivatives.
+    v->curvatures()->dKr = (kr2 - kr1) / (inter2 - inter1).norm();
+    kr_derivatives.push_back(v->curvatures()->dKr);
+  }
+
+  // At that point, we have the derivatives for each vertex of iFace.
+  // All we have to do now is to use linear interpolation to compute the values at
+  // the extremities of the smooth edge.
+  WXSmoothEdge *sc_edge = sc_layer->getSmoothEdge();
+  WOEdge *sc_oedge = sc_edge->woea();
+  t = sc_edge->ta();
+  if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
+      (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon) {
+    sc_layer->removeSmoothEdge();
+    return;
+  }
+  sc_oedge = sc_edge->woeb();
+  t = sc_edge->tb();
+  if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
+      (1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
+    sc_layer->removeSmoothEdge();
+}
+
+
+// Build Smooth edges
+/////////////////////
+void FEdgeXDetector::buildSmoothEdges(WXShape* iShape){
+  // Make a last pass to build smooth edges from the previous stored values:
+  //--------------------------------------------------------------------------
+  vector<WFace*>& wfaces = iShape->GetFaceList();
+  for(vector<WFace*>::iterator f=wfaces.begin(), fend=wfaces.end();
+  f!=fend;
+  ++f)
+  {
+    vector<WXFaceLayer*>& faceLayers = ((WXFace*)(*f))->getSmoothLayers();
+    for(vector<WXFaceLayer*>::iterator wxfl = faceLayers.begin(), wxflend=faceLayers.end();
+    wxfl!=wxflend;
+    ++wxfl){
+      (*wxfl)->BuildSmoothEdge();
+    }
+  }
+}
diff --git a/source/blender/freestyle/intern/view_map/FEdgeXDetector.h b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h
new file mode 100755
index 00000000000..5e6788c6ff8
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/FEdgeXDetector.h
@@ -0,0 +1,150 @@
+//
+//  Filename         : FEdgeXDetector.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Detects/flags/builds extended features edges on the
+//                     WXEdge structure
+//  Date of creation : 26/10/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef  FEDGEXDETECTOR_H
+# define FEDGEXDETECTOR_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+# include "../winged_edge/WXEdge.h"
+# include "../winged_edge/Curvature.h"
+# include "../system/ProgressBar.h"
+
+using namespace Geometry;
+
+/*! This class takes as input a WXEdge structure and fills it
+ */
+
+class LIB_VIEW_MAP_EXPORT FEdgeXDetector
+{
+public:
+
+  FEdgeXDetector() {
+    _pProgressBar = 0;
+    _computeViewIndependant = true;
+    _bbox_diagonal = 1.0;
+    _meanEdgeSize = 0;
+    _computeRidgesAndValleys = true;
+    _computeSuggestiveContours = true;
+    _sphereRadius = 1.0;
+    _changes = false;
+    _kr_derivative_epsilon = 0.0;
+  }
+  virtual ~FEdgeXDetector() {}
+
+  /*! Process shapes from a WingedEdge containing a list of WShapes */
+  virtual void processShapes(WingedEdge&);
+
+  // GENERAL STUFF
+  virtual void preProcessShape(WXShape* iShape);
+  virtual void preProcessFace(WXFace* iFace);
+  virtual void computeCurvatures(WXVertex *iVertex);
+
+  // SILHOUETTE
+  virtual void processSilhouetteShape(WXShape* iShape);
+  virtual void ProcessSilhouetteFace(WXFace *iFace);
+  virtual void ProcessSilhouetteEdge(WXEdge *iEdge);
+
+  // CREASE
+  virtual void processCreaseShape(WXShape* iShape);
+  virtual void ProcessCreaseEdge(WXEdge *iEdge);
+
+  // BORDER
+  virtual void processBorderShape(WXShape* iShape);
+  virtual void ProcessBorderEdge(WXEdge *iEdge);
+
+  // RIDGES AND VALLEYS
+  virtual void processRidgesAndValleysShape(WXShape* iShape);
+  virtual void ProcessRidgeFace(WXFace *iFace);
+
+  // SUGGESTIVE CONTOURS
+  virtual void processSuggestiveContourShape(WXShape* iShape);
+  virtual void ProcessSuggestiveContourFace(WXFace *iFace);
+  virtual void postProcessSuggestiveContourShape(WXShape* iShape);
+  virtual void postProcessSuggestiveContourFace(WXFace *iFace);
+  /*! Sets the minimal derivative of the radial curvature for suggestive contours
+   *  \param dkr
+   *    The minimal derivative of the radial curvature
+   */
+  inline void setSuggestiveContourKrDerivativeEpsilon(real dkr) {
+    if (dkr != _kr_derivative_epsilon){
+      _kr_derivative_epsilon = dkr;
+      _changes = true;
+    }
+  }
+
+  // EVERYBODY
+  virtual void buildSmoothEdges(WXShape* iShape);
+
+  /*! Sets the current viewpoint */
+  inline void setViewpoint(const Vec3r& ivp) {_Viewpoint = ivp;}
+  inline void enableRidgesAndValleysFlag(bool b) {_computeRidgesAndValleys = b;}
+  inline void enableSuggestiveContours(bool b) {_computeSuggestiveContours = b;}
+  /*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation)
+   *  \param r
+   *    The radius of the sphere expressed as a ratio of the mean edge size
+   */
+  inline void setSphereRadius(real r) {
+    if(r!=_sphereRadius){
+      _sphereRadius = r;
+      _changes=true;
+    }
+  }
+
+  inline void setProgressBar(ProgressBar *iProgressBar) {_pProgressBar = iProgressBar;}
+
+protected:
+
+  Vec3r _Viewpoint;
+  real _bbox_diagonal; // diagonal of the current processed shape bbox
+  //oldtmp values
+  bool _computeViewIndependant;
+  real _meanK1;
+  real _meanKr;
+  real _minK1;
+  real _minKr;
+  real _maxK1;
+  real _maxKr;
+  unsigned _nPoints;
+  real _meanEdgeSize;
+
+  bool _computeRidgesAndValleys;
+  bool _computeSuggestiveContours;
+  real _sphereRadius; // expressed as a ratio of the mean edge size
+  bool _changes;
+
+  real _kr_derivative_epsilon;
+
+  ProgressBar *_pProgressBar;
+};
+
+#endif // FEDGEDXETECTOR_H
diff --git a/source/blender/freestyle/intern/view_map/Functions0D.cpp b/source/blender/freestyle/intern/view_map/Functions0D.cpp
new file mode 100755
index 00000000000..c868510624c
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Functions0D.cpp
@@ -0,0 +1,356 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "Functions0D.h"
+# include "ViewMap.h"
+
+using namespace std;
+
+namespace Functions0D {
+
+  // Internal function
+  FEdge* getFEdge(Interface0D& it1, Interface0D& it2){
+    return it1.getFEdge(it2);
+  }
+
+  void getFEdges(Interface0DIterator& it,
+                 FEdge*& fe1,
+                 FEdge*& fe2) {
+    // count number of vertices
+    Interface0DIterator prev = it, next = it;
+    ++next;
+    int count = 1;
+    while((!prev.isBegin()) && (count < 3))
+      { 
+        --prev;
+        ++count;
+      }
+    while((!next.isEnd()) && (count < 3))
+      {
+        ++next;
+        ++count;
+      } 
+    if(count < 3)
+      {
+        // if we only have 2 vertices
+        FEdge * fe = 0;
+        Interface0DIterator tmp = it;
+        if(it.isBegin())
+          {
+            ++tmp;
+            fe = it->getFEdge(*tmp);
+          }
+        else
+          {
+            --tmp;
+            fe = it->getFEdge(*tmp);
+          }
+        fe1 = fe;
+        fe2 = 0;
+      }  
+    else 
+      {
+        // we have more than 2 vertices
+        bool begin=false,last=false;
+        Interface0DIterator previous = it;
+        if(!previous.isBegin())
+          --previous;
+        else
+          begin=true;
+        Interface0DIterator next = it;
+        ++next;
+        if(next.isEnd())
+          last = true;
+        if(begin)
+          {
+            fe1 = it->getFEdge(*next);
+            fe2 = 0;
+          }
+        else if(last)
+          {
+            fe1 = previous->getFEdge(*it);
+            fe2 = 0;
+          }
+        else
+          {
+            fe1 = previous->getFEdge(*it);
+            fe2 = it->getFEdge(*next);
+          }
+      }
+  }
+
+  void getViewEdges(Interface0DIterator &it,
+                    ViewEdge *&ve1,
+                    ViewEdge *&ve2)
+  {
+    FEdge * fe1, *fe2;
+    getFEdges(it, fe1, fe2);
+    ve1 = fe1->viewedge();
+    if(fe2 != 0)
+      {
+        ve2 = fe2->viewedge();
+        if(ve2 == ve1)
+          ve2 = 0;
+      }
+    else
+      ve2 = 0;
+  }
+
+  ViewShape* getShapeF0D(Interface0DIterator& it)
+  {
+    ViewEdge *ve1, *ve2;
+    getViewEdges(it, ve1, ve2);
+    return ve1->viewShape();
+  }
+
+  void getOccludersF0D(Interface0DIterator& it, set<ViewShape*>& oOccluders){
+    ViewEdge * ve1, *ve2;
+    getViewEdges(it, ve1, ve2);
+    occluder_container::const_iterator oit = ve1->occluders_begin();
+    occluder_container::const_iterator oitend = ve1->occluders_end();
+
+    for(;oit!=oitend; ++oit)
+      oOccluders.insert((*oit));  
+
+    if(ve2!=0){
+      oit = ve2->occluders_begin();
+      oitend = ve2->occluders_end();
+      for(;oit!=oitend; ++oit)
+        oOccluders.insert((*oit)); 
+    }
+  }
+
+  ViewShape * getOccludeeF0D(Interface0DIterator& it){
+    ViewEdge * ve1, *ve2;
+    getViewEdges(it, ve1, ve2);
+    ViewShape *aShape = ve1->aShape();
+    return aShape;
+  }
+    
+  //
+  Vec2f VertexOrientation2DF0D::operator()(Interface0DIterator& iter) {
+    Vec2f A,C;
+    Vec2f B(iter->getProjectedX(), iter->getProjectedY());
+    if(iter.isBegin())
+      A = Vec2f(iter->getProjectedX(), iter->getProjectedY());
+    else
+      {
+	Interface0DIterator previous = iter;
+	--previous ;
+	A = Vec2f(previous->getProjectedX(), previous->getProjectedY());
+      }
+    Interface0DIterator next = iter;
+    ++next ;
+    if(next.isEnd())
+      C = Vec2f(iter->getProjectedX(), iter->getProjectedY());
+    else
+      C = Vec2f(next->getProjectedX(), next->getProjectedY());
+
+    Vec2f AB(B-A);
+    if(AB.norm() != 0)
+      AB.normalize();
+    Vec2f BC(C-B);
+    if(BC.norm() != 0)
+      BC.normalize();
+    Vec2f res (AB + BC);
+    if(res.norm() != 0)
+      res.normalize();
+    return res;
+  }
+
+  Vec3f VertexOrientation3DF0D::operator()(Interface0DIterator& iter) {
+    Vec3r A,C;
+    Vec3r B(iter->getX(), iter->getY(), iter->getZ());
+    if(iter.isBegin())
+      A = Vec3r(iter->getX(), iter->getY(), iter->getZ());
+    else
+      {
+	Interface0DIterator previous = iter;
+	--previous ;
+	A = Vec3r(previous->getX(), previous->getY(), previous->getZ());
+      }
+    Interface0DIterator next = iter;
+    ++next ;
+    if(next.isEnd())
+      C = Vec3r(iter->getX(), iter->getY(), iter->getZ());
+    else
+      C = Vec3r(next->getX(), next->getY(), next->getZ());
+
+    Vec3r AB(B-A);
+    if(AB.norm() != 0)
+      AB.normalize();
+    Vec3r BC(C-B);
+    if(BC.norm() != 0)
+      BC.normalize();
+    Vec3f res (AB + BC);
+    if(res.norm() != 0)
+      res.normalize();
+    return res;
+  }
+
+  real Curvature2DAngleF0D::operator()(Interface0DIterator& iter) {
+    Interface0DIterator tmp1 = iter, tmp2 = iter;
+    ++tmp2;
+    unsigned count = 1;
+    while((!tmp1.isBegin()) && (count < 3))
+      {
+	--tmp1;
+	++count;
+      }
+    while((!tmp2.isEnd()) && (count < 3))
+      {
+	++tmp2;
+	++count;
+      }
+    if(count < 3)
+      return 0; // if we only have 2 vertices
+
+    Interface0DIterator v = iter;
+    if(iter.isBegin())
+      ++v;
+    Interface0DIterator next=v;
+    ++next;
+    if(next.isEnd())
+      {
+	next = v;
+	--v;
+      }
+    Interface0DIterator prev=v;
+    --prev;
+
+    Vec2r A(prev->getProjectedX(), prev->getProjectedY());
+    Vec2r B(v->getProjectedX(), v->getProjectedY());
+    Vec2r C(next->getProjectedX(), next->getProjectedY());
+    Vec2r AB(B-A);
+    Vec2r BC(C-B);
+    Vec2r N1(-AB[1], AB[0]);
+    if(N1.norm() != 0)
+      N1.normalize();
+    Vec2r N2(-BC[1], BC[0]);
+    if(N2.norm() != 0)
+      N2.normalize();
+    if((N1.norm() == 0) && (N2.norm() == 0))
+      {
+	Exception::raiseException();
+	return 0; 
+      }
+    double cosin = N1*N2;
+    if(cosin > 1)
+      cosin = 1;
+    if(cosin < -1)
+      cosin = -1;
+    return acos(cosin);
+  }
+
+  real ZDiscontinuityF0D::operator()(Interface0DIterator& iter) {
+    FEdge *fe1, *fe2;
+    getFEdges(iter, fe1, fe2);
+    real result ;
+    result = fe1->z_discontinuity();
+    if(fe2!=0){
+      result += fe2->z_discontinuity();
+      result /= 2.f;
+    }
+    return result;
+  }
+
+  Vec2f Normal2DF0D::operator()(Interface0DIterator& iter) {
+    FEdge *fe1, *fe2;
+    getFEdges(iter,fe1,fe2);
+    Vec3f e1(fe1->orientation2d());
+    Vec2f n1(e1[1], -e1[0]);
+    Vec2f n(n1);
+    if(fe2 != 0)
+      {
+	Vec3f e2(fe2->orientation2d());
+	Vec2f n2(e2[1], -e2[0]);
+	n += n2;
+      }
+    n.normalize();
+    return n;
+  }
+
+  Material MaterialF0D::operator()(Interface0DIterator& iter) {
+    FEdge *fe1, *fe2;
+    getFEdges(iter,fe1,fe2);
+    
+    if(fe1 == 0)
+      getFEdges(iter, fe1, fe2);
+    Material mat;
+    if(fe1->isSmooth())
+      mat = ((FEdgeSmooth*)fe1)->material();
+    else
+      mat = ((FEdgeSharp*)fe1)->bMaterial();
+    //    const SShape * sshape = getShapeF0D(iter);
+    //    return sshape->material();
+    return mat;
+  }
+
+  Id ShapeIdF0D::operator()(Interface0DIterator& iter) {
+    ViewShape * vshape = getShapeF0D(iter);
+    return vshape->getId();
+  }
+
+  unsigned int QuantitativeInvisibilityF0D::operator()(Interface0DIterator& iter) {
+    ViewEdge * ve1, *ve2;
+    getViewEdges(iter,ve1,ve2);
+    unsigned int qi1, qi2;
+    qi1 = ve1->qi();
+    if(ve2 != 0){
+      qi2 = ve2->qi();
+      if(qi2!=qi1)
+        cout << "QuantitativeInvisibilityF0D: ambiguous evaluation for point " << iter->getId() << endl;
+    }
+    return qi1;
+  }
+
+  Nature::EdgeNature CurveNatureF0D::operator()(Interface0DIterator& iter) {
+    Nature::EdgeNature nat = 0;
+    ViewEdge * ve1, *ve2;
+    getViewEdges(iter, ve1, ve2);
+    nat |= ve1->getNature();
+    if(ve2!=0)
+      nat |= ve2->getNature();
+    return nat;
+  }
+
+  vector<ViewShape*> GetOccludersF0D::operator()(Interface0DIterator& iter) {
+    set<ViewShape*> occluders;
+    getOccludersF0D(iter,occluders);
+    vector<ViewShape*> vsOccluders;
+    // vsOccluders.insert(vsOccluders.begin(), occluders.begin(), occluders.end());
+    for(set<ViewShape*>::iterator it=occluders.begin(), itend=occluders.end();
+    it!=itend;
+    ++it){
+      vsOccluders.push_back((*it));
+    }
+    return vsOccluders;
+  }
+
+  ViewShape* GetShapeF0D::operator()(Interface0DIterator& iter) {
+    return getShapeF0D(iter);
+  }
+
+  ViewShape* GetOccludeeF0D::operator()(Interface0DIterator& iter) {
+    return getOccludeeF0D(iter);
+  }
+
+} // end of namespace Functions0D
diff --git a/source/blender/freestyle/intern/view_map/Functions0D.h b/source/blender/freestyle/intern/view_map/Functions0D.h
new file mode 100755
index 00000000000..3160546da2f
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Functions0D.h
@@ -0,0 +1,487 @@
+//
+//  Filename         : Functions0D.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Functions taking 0D input
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  FUNCTIONS0D_H
+# define FUNCTIONS0D_H
+
+# include "../system/Precision.h"
+# include "Interface0D.h"
+# include "../geometry/Geom.h"
+# include "../system/Exception.h"
+# include "../scene_graph/Material.h"
+# include <set>
+# include <vector>
+class FEdge;
+class ViewEdge;
+class SShape;
+
+using namespace Geometry;
+
+//
+// UnaryFunction0D (base class for functions in 0D)
+//
+///////////////////////////////////////////////////////////
+
+template <class T>
+/*! Base class for Unary Functions (functors) working
+ *  on Interface0DIterator.
+ *  A unary function will be used by calling
+ *  its operator() on an Interface0DIterator.
+ *  \attention In the scripting language, there exists
+ *  several prototypes depending on the returned value type.
+ *  For example, you would inherit from a UnaryFunction0DDouble
+ *  if you wish to define a function that returns a double.
+ *  The different existing prototypes are:
+ *    - UnaryFunction0DVoid
+ *    - UnaryFunction0DUnsigned
+ *    - UnaryFunction0DReal
+ *    - UnaryFunction0DFloat
+ *    - UnaryFunction0DDouble
+ *    - UnaryFunction0DVec2f
+ *    - UnaryFunction0DVec3f
+ */
+class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction0D
+{
+public:
+
+  /*! The type of the value
+   *  returned by the functor.
+   */
+  typedef T ReturnedValueType;
+  /*! Default constructor. */
+  UnaryFunction0D() {}
+  /*! Destructor; */
+  virtual ~UnaryFunction0D() {}
+  /*! Returns the string "UnaryFunction0D" */
+  virtual string getName() const {
+    return "UnaryFunction0D";
+  }
+  /*! The operator ().
+   *  \param iter 
+   *    An Interface0DIterator pointing onto
+   *    the point at which we wish to evaluate
+   *    the function.
+   *  \return the result of the function of type T.
+   */
+  virtual T operator()(Interface0DIterator& iter) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return T();
+  }
+};
+
+# ifdef SWIG
+%feature("director")			UnaryFunction0D<void>;
+%feature("director")			UnaryFunction0D<unsigned>;
+%feature("director")			UnaryFunction0D<float>;
+%feature("director")			UnaryFunction0D<double>;
+%feature("director")			UnaryFunction0D<Vec2f>;
+%feature("director")			UnaryFunction0D<Vec3f>;
+%feature("director")			UnaryFunction0D<Id>;
+
+%template(UnaryFunction0DVoid)		UnaryFunction0D<void>;
+%template(UnaryFunction0DUnsigned)	UnaryFunction0D<unsigned>;
+%template(UnaryFunction0DFloat)		UnaryFunction0D<float>;
+%template(UnaryFunction0DDouble)	UnaryFunction0D<double>;
+%template(UnaryFunction0DVec2f)		UnaryFunction0D<Vec2f>;
+%template(UnaryFunction0DVec3f)		UnaryFunction0D<Vec3f>;
+%template(UnaryFunction0DId)		UnaryFunction0D<Id>;
+%template(UnaryFunction0DViewShape)		UnaryFunction0D<ViewShape*>;
+%template(UnaryFunction0DVectorViewShape)		UnaryFunction0D<std::vector<ViewShape*> >;
+# endif // SWIG
+
+
+//
+// Functions definitions
+//
+///////////////////////////////////////////////////////////
+class ViewShape;
+namespace Functions0D {
+
+  // GetXF0D
+  /*! Returns the X 3D coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetXF0D"*/
+    string getName() const {
+      return "GetXF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getX();
+    }
+  };
+
+  // GetYF0D
+  /*! Returns the Y 3D coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetYF0D"*/
+    string getName() const {
+      return "GetYF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getY();
+    }
+  };
+
+  // GetZF0D
+  /*! Returns the Z 3D coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetZF0D"*/
+    string getName() const {
+      return "GetZF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getZ();
+    }
+  };
+
+  // GetProjectedXF0D
+  /*! Returns the X 3D projected coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetProjectedXF0D"*/
+    string getName() const {
+      return "GetProjectedXF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getProjectedX();
+    }
+  };
+
+  // GetProjectedYF0D
+  /*! Returns the Y projected 3D coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetProjectedYF0D"*/
+    string getName() const {
+      return "GetProjectedYF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getProjectedY();
+    }
+  };
+
+  // GetProjectedZF0D
+  /*! Returns the Z projected 3D coordinate of an Interface0D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "GetProjectedZF0D"*/
+    string getName() const {
+      return "GetProjectedZF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter) {
+      return iter->getProjectedZ();
+    }
+  };
+
+  // GetCurvilinearAbscissaF0D
+  /*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
+  class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
+  {
+  public:
+    /*! Returns the string "GetCurvilinearAbscissaF0D"*/
+    string getName() const {
+      return "GetCurvilinearAbscissaF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter) {
+      return iter.t();
+    }
+  };
+
+  // GetParameterF0D
+  /*! Returns the parameter of an Interface0D in the context of its 1D element. */
+  class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
+  {
+  public:
+    /*! Returns the string "GetCurvilinearAbscissaF0D"*/
+    string getName() const {
+      return "GetParameterF0D";
+    }
+    /*! the () operator.*/
+    float operator()(Interface0DIterator& iter) {
+      return iter.u();
+    }
+  };
+
+  // VertexOrientation2DF0D
+  /*! Returns a Vec2r giving the 2D oriented tangent to the 1D element
+   *  to which the Interface0DIterator& belongs to and
+   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+   */
+  class LIB_VIEW_MAP_EXPORT VertexOrientation2DF0D : public UnaryFunction0D<Vec2f>
+  {
+  public:
+    /*! Returns the string "VertexOrientation2DF0D"*/
+    string getName() const {
+      return "VertexOrientation2DF0D";
+    }
+    /*! the () operator.*/
+    Vec2f operator()(Interface0DIterator& iter);
+  };
+
+  // VertexOrientation3DF0D
+  /*! Returns a Vec3r giving the 3D oriented tangent to the 1D element
+   *  to which the Interface0DIterator& belongs to and
+   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+   */
+  class LIB_VIEW_MAP_EXPORT VertexOrientation3DF0D : public UnaryFunction0D<Vec3f>
+  {
+  public:
+    /*! Returns the string "VertexOrientation3DF0D"*/
+    string getName() const {
+      return "VertexOrientation3DF0D";
+    }
+    /*! the () operator.*/
+    Vec3f operator()(Interface0DIterator& iter);
+  };
+
+  // Curvature2DAngleF0D
+  /*! Returns a real giving the 2D curvature (as an angle) of the 1D element
+   *  to which the Interface0DIterator& belongs to and
+   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+   */
+  class LIB_VIEW_MAP_EXPORT Curvature2DAngleF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "Curvature2DAngleF0D"*/
+    string getName() const {
+      return "Curvature2DAngleF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter);
+  };
+
+  // ZDiscontinuity
+  /*! Returns a real giving the distance between
+   *  and Interface0D and the shape that lies behind (occludee).
+   *  This distance is evaluated in the camera space and normalized
+   *  between 0 and 1. Therefore, if no oject is occluded by the
+   *  shape to which the Interface0D belongs to, 1 is returned.
+   */
+  class LIB_VIEW_MAP_EXPORT ZDiscontinuityF0D : public UnaryFunction0D<real>
+  {
+  public:
+    /*! Returns the string "ZDiscontinuityF0D"*/
+    string getName() const {
+      return "ZDiscontinuityF0D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface0DIterator& iter);
+  };
+
+  // Normal2DF0D
+  /*! Returns a Vec2f giving the normalized 2D normal to the 1D element
+   *  to which the Interface0DIterator& belongs to and
+   *  evaluated at the Interface0D pointed by this Interface0DIterator&.
+   */
+  class LIB_VIEW_MAP_EXPORT Normal2DF0D : public UnaryFunction0D<Vec2f>
+  {
+  public:
+    /*! Returns the string "Normal2DF0D"*/
+    string getName() const {
+      return "Normal2DF0D";
+    }
+    /*! the () operator.*/
+    Vec2f operator()(Interface0DIterator& iter);
+  };
+
+  // MaterialF0D
+  /*! Returns the material of the object evaluated at the Interface0D.
+   *  This evaluation can be ambiguous (in the case of a TVertex for example.
+   *  This functor tries to remove this ambiguity using the context
+   *  offered by the 1D element to which the Interface0DIterator& belongs
+   *  to and by arbitrary chosing the material of the face
+   *  that lies on its left when following the 1D element if there
+   *  are two different materials on each side of the point.
+   *  However, there still can be problematic cases, and the user willing
+   *  to deal with this cases in a specific way should implement
+   *  its own getMaterial functor.
+   */
+  class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<Material>
+  {
+  public:
+    /*! Returns the string "MaterialF0D"*/
+    string getName() const {
+      return "MaterialF0D";
+    }
+    /*! the () operator.*/
+    Material operator()(Interface0DIterator& iter);
+  };
+
+  // ShapeIdF0D
+  /*! Returns the Id of the Shape the Interface0D belongs to.
+   *  This evaluation can be ambiguous (in the case of a TVertex for example).
+   *  This functor tries to remove this ambiguity using the context
+   *  offered by the 1D element to which the Interface0DIterator& belongs
+   *  to.
+   *  However, there still can be problematic cases, and the user willing
+   *  to deal with this cases in a specific way should implement
+   *  its own getShapeIdF0D functor.
+   */
+  class LIB_VIEW_MAP_EXPORT ShapeIdF0D : public UnaryFunction0D<Id>
+  {
+  public:
+    /*! Returns the string "ShapeIdF0D"*/
+    string getName() const {
+      return "ShapeIdF0D";
+    }
+    /*! the () operator.*/
+    Id operator()(Interface0DIterator& iter);
+  };
+
+  // QiF0D
+  /*! Returns the quantitative invisibility of this Interface0D.
+   *  This evaluation can be ambiguous (in the case of a TVertex for example).
+   *  This functor tries to remove this ambiguity using the context
+   *  offered by the 1D element to which the Interface0DIterator& belongs
+   *  to.
+   *  However, there still can be problematic cases, and the user willing
+   *  to deal with this cases in a specific way should implement
+   *  its own getQIF0D functor.
+   */
+  class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int>
+  {
+  public:
+    /*! Returns the string "QuantitativeInvisibilityF0D"*/
+    string getName() const {
+      return "QuantitativeInvisibilityF0D";
+    }
+    /*! the () operator.*/
+    unsigned int operator()(Interface0DIterator& iter);
+  };
+
+  // CurveNatureF0D
+  /*! Returns the Nature::EdgeNature of the 1D element the
+   *  Interface0DIterator& belongs to.
+   */
+  class LIB_VIEW_MAP_EXPORT CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature>
+  {
+  public:
+    /*! Returns the string "QuantitativeInvisibilityF0D"*/
+    string getName() const {
+      return "CurveNatureF0D";
+    }
+    /*! the () operator.*/
+    Nature::EdgeNature operator()(Interface0DIterator& iter);
+  };
+  
+  // GetShapeF0D
+  /*! Returns the ViewShape* 
+   *  containing the Interface0D
+   */
+  class LIB_VIEW_MAP_EXPORT GetShapeF0D : public UnaryFunction0D< ViewShape*>
+  {
+  public:
+    /*! Returns the string "GetShapeF0D"*/
+    string getName() const {
+      return "GetShapeF0D";
+    }
+    /*! the () operator.*/
+    ViewShape* operator()(Interface0DIterator& iter);
+  };
+
+  // GetOccludersF0D
+  /*! Returns a vector containing the ViewShape* 
+   *  occluding the Interface0D
+   */
+  class LIB_VIEW_MAP_EXPORT GetOccludersF0D : public UnaryFunction0D< std::vector<ViewShape*> >
+  {
+  public:
+    /*! Returns the string "GetOccludersF0D"*/
+    string getName() const {
+      return "GetOccludersF0D";
+    }
+    /*! the () operator.*/
+    std::vector<ViewShape*> operator()(Interface0DIterator& iter);
+  };
+
+  // GetOccludeeF0D
+  /*! Returns the ViewShape* 
+   *  "occluded" by the Interface0D
+   */
+  class LIB_VIEW_MAP_EXPORT GetOccludeeF0D: public UnaryFunction0D< ViewShape*>
+  {
+  public:
+    /*! Returns the string "GetOccludeeF0D"*/
+    string getName() const {
+      return "GetOccludeeF0D";
+    }
+    /*! the () operator.*/
+    ViewShape* operator()(Interface0DIterator& iter);
+  };
+
+  
+
+  /////////////////////////// Internal ////////////////////////////
+
+  // getFEdge
+  LIB_VIEW_MAP_EXPORT
+  FEdge* getFEdge(Interface0D& it1, Interface0D& it2);
+
+  // getFEdges
+  LIB_VIEW_MAP_EXPORT
+  void  getFEdges(Interface0DIterator& it,
+                 FEdge*& fe1,
+                 FEdge*& fe2);
+
+  // getViewEdges
+  LIB_VIEW_MAP_EXPORT
+  void  getViewEdges(Interface0DIterator& it,
+                    ViewEdge *&ve1,
+                    ViewEdge *&ve2);
+
+  // getShapeF0D
+  LIB_VIEW_MAP_EXPORT
+  ViewShape* getShapeF0D(Interface0DIterator& it);
+
+  // getOccludersF0D
+  LIB_VIEW_MAP_EXPORT
+  void getOccludersF0D(Interface0DIterator& it, std::set<ViewShape*>& oOccluders);
+
+  // getOccludeeF0D
+  LIB_VIEW_MAP_EXPORT
+  ViewShape* getOccludeeF0D(Interface0DIterator& it);
+
+} // end of namespace Functions0D
+
+#endif // FUNCTIONS0D_H
diff --git a/source/blender/freestyle/intern/view_map/Functions1D.cpp b/source/blender/freestyle/intern/view_map/Functions1D.cpp
new file mode 100755
index 00000000000..a34124ded31
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Functions1D.cpp
@@ -0,0 +1,209 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "Functions1D.h"
+using namespace std;
+
+namespace Functions1D {
+
+  real GetXF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real GetYF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real GetZF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real GetProjectedXF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real GetProjectedYF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real GetProjectedZF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  Vec2f Orientation2DF1D::operator()(Interface1D& inter) {
+    FEdge * fe = dynamic_cast<FEdge*>(&inter);
+    if(fe){
+      Vec3r res = fe->orientation2d();
+      return Vec2f(res[0], res[1]);
+    }
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  Vec3f Orientation3DF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  real ZDiscontinuityF1D::operator()(Interface1D& inter) {
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+  
+  unsigned QuantitativeInvisibilityF1D::operator()(Interface1D& inter) {
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve)
+      return ve->qi();
+    FEdge *fe = dynamic_cast<FEdge*>(&inter);
+    if(fe)
+      return ve->qi();
+    return integrate(_func, inter.verticesBegin(), inter.verticesEnd(), _integration);
+  }
+
+  Nature::EdgeNature CurveNatureF1D::operator()(Interface1D& inter) {
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve)
+      return ve->getNature();
+    else{
+      // we return a nature that contains every 
+      // natures of the viewedges spanned by the chain.
+      Nature::EdgeNature nat = Nature::NO_FEATURE;
+      Interface0DIterator it = inter.verticesBegin();
+      while(!it.isEnd()){
+        nat |= _func(it);
+        ++it;
+      }
+      return nat;
+    }
+  }
+  
+  void TimeStampF1D::operator()(Interface1D& inter) {
+    TimeStamp *timestamp = TimeStamp::instance();
+    inter.setTimeStamp(timestamp->getTimeStamp());
+  }
+
+  void ChainingTimeStampF1D::operator()(Interface1D& inter) {
+    TimeStamp *timestamp = TimeStamp::instance();
+    ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+    if(ve)
+      ve->setChainingTimeStamp(timestamp->getTimeStamp());
+  }
+  
+  void IncrementChainingTimeStampF1D::operator()(Interface1D& inter) {
+    ViewEdge *ve = dynamic_cast<ViewEdge*>(&inter);
+    if(ve)
+      ve->setChainingTimeStamp(ve->getChainingTimeStamp()+1);
+  }
+
+  vector<ViewShape*> GetShapeF1D::operator()(Interface1D& inter) {
+    vector<ViewShape*> shapesVector;
+    set<ViewShape*> shapesSet;
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      shapesVector.push_back(ve->viewShape());
+    }else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it)
+        shapesSet.insert(Functions0D::getShapeF0D(it));
+      shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+    }
+    return shapesVector;
+  }
+
+  vector<ViewShape*> GetOccludersF1D::operator()(Interface1D& inter) {
+    vector<ViewShape*> shapesVector;
+    set<ViewShape*> shapesSet;
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      return ve->occluders();
+    }else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it){
+        Functions0D::getOccludersF0D(it, shapesSet);
+      }
+      shapesVector.insert(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+    }
+    return shapesVector;
+  }
+
+  vector<ViewShape*> GetOccludeeF1D::operator()(Interface1D& inter) {
+    vector<ViewShape*> shapesVector;
+    set<ViewShape*> shapesSet;
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      ViewShape * aShape = ve->aShape();
+      shapesVector.push_back(aShape);
+    }else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it){
+        shapesSet.insert(Functions0D::getOccludeeF0D(it));
+      }
+    shapesVector.insert<set<ViewShape*>::iterator>(shapesVector.begin(), shapesSet.begin(), shapesSet.end());
+    }
+    return shapesVector;
+  }
+  // Internal
+  ////////////
+
+  void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes){
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      ViewShape * aShape = ve->aShape();
+      if(aShape == 0){
+        oShapes.insert(0);
+        return;
+      }
+      oShapes.insert(aShape);
+    }
+    else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it)
+        oShapes.insert(Functions0D::getOccludeeF0D(it));
+    }
+  }
+
+  void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes){
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      vector<ViewShape*>& occluders = ve->occluders();
+      oShapes.insert<vector<ViewShape*>::iterator>(occluders.begin(), occluders.end());
+    }
+    else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it){
+        set<ViewShape*> shapes;
+        Functions0D::getOccludersF0D(it, shapes);
+        for(set<ViewShape*>::iterator s=shapes.begin(), send=shapes.end();
+            s!=send;
+            ++s)
+          oShapes.insert(*s);
+      }
+    }
+  }
+
+  void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes){
+    ViewEdge* ve = dynamic_cast<ViewEdge*>(&inter);
+    if (ve){
+      oShapes.insert(ve->viewShape());
+    }else{
+      Interface0DIterator it=inter.verticesBegin(), itend=inter.verticesEnd();
+      for(;it!=itend;++it)
+        oShapes.insert(Functions0D::getShapeF0D(it));
+    }
+  }
+} // end of namespace Functions1D
diff --git a/source/blender/freestyle/intern/view_map/Functions1D.h b/source/blender/freestyle/intern/view_map/Functions1D.h
new file mode 100755
index 00000000000..c92d12ff330
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Functions1D.h
@@ -0,0 +1,537 @@
+//
+//  Filename         : Functions1D.h
+//  Author(s)        : Stephane Grabli, Emmanuel Turquin
+//  Purpose          : Functions taking 1D input
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  FUNCTIONS1D_HPP
+# define FUNCTIONS1D_HPP
+
+# include "../system/Precision.h"
+# include "../system/TimeStamp.h"
+# include "ViewMap.h"
+# include "Functions0D.h"
+# include "Interface1D.h"
+# include "../system/FreestyleConfig.h"
+//
+// UnaryFunction1D (base class for functions in 1D)
+//
+///////////////////////////////////////////////////////////
+
+/*! Base class for Unary Functions (functors) working
+ *  on Interface1D.
+ *  A unary function will be used by calling
+ *  its operator() on an Interface1D.
+ *  \attention In the scripting language, there exists
+ *  several prototypes depending on the returned value type.
+ *  For example, you would inherit from a UnaryFunction1DDouble
+ *  if you wish to define a function that returns a double.
+ *  The different existing prototypes are:
+ *    - UnaryFunction1DVoid
+ *    - UnaryFunction1DUnsigned
+ *    - UnaryFunction1DReal
+ *    - UnaryFunction1DFloat
+ *    - UnaryFunction1DDouble
+ *    - UnaryFunction1DVec2f
+ *    - UnaryFunction1DVec3f
+ */
+template <class T>
+class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D
+{
+public:
+  /*! The type of the value
+   *  returned by the functor.
+   */
+  typedef T ReturnedValueType;
+  
+  /*! Default constructor */
+  UnaryFunction1D(){_integration = MEAN;}
+  /*! Builds a UnaryFunction1D from an integration type.
+   *  \param iType
+   *    In case the result for the Interface1D would be
+   *    obtained by evaluating a 0D function over the different
+   *    Interface0D of the Interface1D, \a iType tells which
+   *    integration method to use.
+   *    The default integration method is the MEAN.
+   */
+  UnaryFunction1D(IntegrationType iType){_integration = iType;}
+  /*! destructor. */
+  virtual ~UnaryFunction1D() {}
+
+  /*! returns the string "UnaryFunction1D". */
+  virtual string getName() const {
+    return "UnaryFunction1D";
+  }
+  /*! The operator ().
+   *  \param inter 
+   *    The Interface1D on which we wish to evaluate
+   *    the function.
+   *  \return the result of the function of type T.
+   */
+  virtual T operator()(Interface1D& inter) {
+    cerr << "Warning: operator() not implemented" << endl;
+    return T(0);
+  }
+  /*! Sets the integration method */
+  void setIntegrationType(IntegrationType integration) {
+    _integration = integration;
+  }
+  /*! Returns the integration method. */
+  IntegrationType getIntegrationType() const {
+    return _integration;
+  }
+
+protected:
+
+  IntegrationType _integration;
+};
+
+# ifdef SWIG
+%feature("director")			UnaryFunction1D<void>;
+%feature("director")			UnaryFunction1D<unsigned>;
+%feature("director")			UnaryFunction1D<float>;
+%feature("director")			UnaryFunction1D<double>;
+%feature("director")			UnaryFunction1D<Vec2f>;
+%feature("director")			UnaryFunction1D<Vec3f>;
+
+%template(UnaryFunction1DVoid)		UnaryFunction1D<void>;
+%template(UnaryFunction1DUnsigned)	UnaryFunction1D<unsigned>;
+%template(UnaryFunction1DFloat)		UnaryFunction1D<float>;
+%template(UnaryFunction1DDouble)	UnaryFunction1D<double>;
+%template(UnaryFunction1DVec2f)		UnaryFunction1D<Vec2f>;
+%template(UnaryFunction1DVec3f)		UnaryFunction1D<Vec3f>;
+%template(UnaryFunction1DVectorViewShape)		UnaryFunction1D<std::vector<ViewShape*> >;
+# endif // SWIG
+
+
+//
+// Functions definitions
+//
+///////////////////////////////////////////////////////////
+
+namespace Functions1D {
+
+  // GetXF1D
+  /*! Returns the X 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetXF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType){}
+    /*! Returns the string "GetXF1D"*/
+    string getName() const {
+      return "GetXF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter) ;
+  };
+
+  // GetYF1D
+  /*! Returns the Y 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetYF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+    /*! Returns the string "GetYF1D"*/
+    string getName() const {
+      return "GetYF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter) ;
+  };
+
+  // GetZF1D
+  /*! Returns the Z 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetZF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+    /*! Returns the string "GetZF1D"*/
+    string getName() const {
+      return "GetZF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter) ;
+  };
+
+  // GetProjectedXF1D
+  /*! Returns the projected X 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetProjectedXF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+  public:
+    /*! Returns the string "GetProjectedXF1D"*/
+    string getName() const {
+      return "GetProjectedXF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter);
+  };
+  
+  // GetProjectedYF1D
+  /*! Returns the projected Y 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetProjectedYF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+  public:
+    /*! Returns the string "GetProjectedYF1D"*/
+    string getName() const {
+      return "GetProjectedYF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter);
+  };
+
+  // GetProjectedZF1D
+  /*! Returns the projected Z 3D coordinate of an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::GetProjectedZF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+  public:
+    /*! Returns the string "GetProjectedZF1D"*/
+    string getName() const {
+      return "GetProjectedZF1D";
+    }
+    /*! the () operator.*/
+    real operator()(Interface1D& inter);
+  };
+  
+  // Orientation2DF1D
+  /*! Returns the 2D orientation as a Vec2f*/
+  class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
+  {
+  private:
+    Functions0D::VertexOrientation2DF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType){}
+    /*! Returns the string "Orientation2DF1D"*/
+    string getName() const {
+      return "Orientation2DF1D";
+    }
+    /*! the () operator.*/
+    Vec2f operator()(Interface1D& inter);
+  };
+
+  // Orientation3DF1D
+  /*! Returns the 3D orientation as a Vec3f. */
+  class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
+  {
+  private:
+    Functions0D::VertexOrientation3DF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType){}
+    /*! Returns the string "Orientation3DF1D"*/
+    string getName() const {
+      return "Orientation3DF1D";
+    }
+    /*! the () operator.*/    
+    Vec3f operator()(Interface1D& inter);
+  };
+
+  // ZDiscontinuityF1D
+  /*! Returns a real giving the distance between
+   *  and Interface1D and the shape that lies behind (occludee).
+   *  This distance is evaluated in the camera space and normalized
+   *  between 0 and 1. Therefore, if no oject is occluded by the
+   *  shape to which the Interface1D belongs to, 1 is returned.
+   */
+  class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
+  {
+  private:
+    Functions0D::ZDiscontinuityF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
+    /*! Returns the string "ZDiscontinuityF1D"*/
+    string getName() const {
+      return "ZDiscontinuityF1D";
+    }
+    /*! the () operator.*/        
+    real operator()(Interface1D& inter);
+  };
+  
+  // QuantitativeInvisibilityF1D
+  /*! Returns the Quantitative Invisibility of an Interface1D element.
+   *  If the Interface1D is a ViewEdge, then there is no ambiguity
+   *  concerning the result. But, if the Interface1D results of a chaining
+   *  (chain, stroke), then it might be made of several 1D elements
+   *  of different Quantitative Invisibilities.
+   */
+  class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
+  {
+  private:
+    Functions0D::QuantitativeInvisibilityF0D _func;
+  public:
+  /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
+   /*! Returns the string "QuantitativeInvisibilityF1D"*/
+    string getName() const {
+      return "QuantitativeInvisibilityF1D";
+    }
+  /*! the () operator.*/        
+    unsigned operator()(Interface1D& inter);
+  };
+
+  // CurveNatureF1D
+/*! Returns the nature of the Interface1D (silhouette, ridge, crease...).
+ *  Except if the Interface1D is a ViewEdge, this result might be ambiguous.
+ *  Indeed, the Interface1D might result from the gathering of several 1D elements,
+ *  each one being of a different nature. An integration method, such as
+ *  the MEAN, might give, in this case, irrelevant results.
+ */
+  class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
+  {
+  private:
+    Functions0D::CurveNatureF0D _func;
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
+    /*! Returns the string "CurveNatureF1D"*/
+    string getName() const {
+      return "CurveNatureF1D";
+    }
+    /*! the () operator.*/        
+    Nature::EdgeNature operator()(Interface1D& inter);
+  };
+
+  // TimeStampF1D
+/*! Returns the time stamp of the Interface1D. */
+  class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D<void>
+  {
+  public:
+    /*! Returns the string "TimeStampF1D"*/
+    string getName() const {
+      return "TimeStampF1D";
+    }
+    /*! the () operator.*/        
+    void operator()(Interface1D& inter);
+  };
+
+  // IncrementChainingTimeStampF1D
+/*! Increments the chaining time stamp of the Interface1D. */
+  class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D<void>
+  {
+  public:
+    /*! Returns the string "IncrementChainingTimeStampF1D"*/
+    string getName() const {
+      return "IncrementChainingTimeStampF1D";
+    }
+    /*! the () operator.*/        
+    void operator()(Interface1D& inter);
+  };
+
+  // ChainingTimeStampF1D
+/*! Sets the chaining time stamp of the Interface1D. */
+  class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D<void>
+  {
+  public:
+    /*! Returns the string "ChainingTimeStampF1D"*/
+    string getName() const {
+      return "ChainingTimeStampF1D";
+    }
+    /*! the () operator.*/        
+    void operator()(Interface1D& inter);
+  };
+  
+
+  // Curvature2DAngleF1D
+/*! Returns the 2D curvature as an angle for an Interface1D. */
+  class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
+  {
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
+    /*! Returns the string "Curvature2DAngleF1D"*/
+    string getName() const {
+      return "Curvature2DAngleF1D";
+    }
+    /*! the () operator.*/        
+    real operator()(Interface1D& inter) {
+      return integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
+    }
+  private:
+    Functions0D::Curvature2DAngleF0D	_fun;
+  };
+
+  // Normal2DF1D
+  /*! Returns the 2D normal for an interface 1D. */
+  class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
+  {
+  public:
+    /*! Builds the functor.
+     *  \param iType
+     *    The integration method used to compute
+     *    a single value from a set of values.
+     */
+    Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
+    /*! Returns the string "Normal2DF1D"*/
+    string getName() const {
+      return "Normal2DF1D";
+    }
+    /*! the () operator.*/        
+    Vec2f operator()(Interface1D& inter) {
+      return integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
+    }
+  private:
+    Functions0D::Normal2DF0D	_fun;
+  };
+
+  // GetShapeF1D
+  /*! Returns list of shapes covered by this Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+  {
+  public:
+    /*! Builds the functor.
+     */
+    GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+    /*! Returns the string "GetShapeF1D"*/
+    string getName() const {
+      return "GetShapeF1D";
+    }
+    /*! the () operator.*/        
+    std::vector<ViewShape*> operator()(Interface1D& inter);
+  };
+
+  // GetOccludersF1D
+  /*! Returns list of occluding shapes covered by this Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+  {
+  public:
+    /*! Builds the functor.
+     */
+    GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+    /*! Returns the string "GetOccludersF1D"*/
+    string getName() const {
+      return "GetOccludersF1D";
+    }
+    /*! the () operator.*/        
+    std::vector<ViewShape*> operator()(Interface1D& inter);
+  };
+
+  // GetOccludeeF1D
+  /*! Returns list of occluded shapes covered by this Interface1D. */
+  class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
+  {
+  public:
+    /*! Builds the functor.
+     */
+    GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
+    /*! Returns the string "GetOccludeeF1D"*/
+    string getName() const {
+      return "GetOccludeeF1D";
+    }
+    /*! the () operator.*/        
+    std::vector<ViewShape*> operator()(Interface1D& inter);
+  };
+
+  // internal
+  ////////////
+
+  // getOccludeeF1D
+  LIB_VIEW_MAP_EXPORT
+  void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+
+  // getOccludersF1D
+  LIB_VIEW_MAP_EXPORT
+  void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+
+  // getShapeF1D
+  LIB_VIEW_MAP_EXPORT
+  void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
+  
+} // end of namespace Functions1D
+
+#endif // FUNCTIONS1D_HPP
diff --git a/source/blender/freestyle/intern/view_map/Interface0D.h b/source/blender/freestyle/intern/view_map/Interface0D.h
new file mode 100755
index 00000000000..fd2e882e9b6
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Interface0D.h
@@ -0,0 +1,353 @@
+//
+//  Filename         : Interface0D.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Interface to 0D elts
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  INTERFACE0D_H
+# define INTERFACE0D_H
+
+# include <string>
+# include <iostream>
+# include "../system/Id.h"
+# include "../system/Precision.h"
+# include "../winged_edge/Nature.h"
+# include "../geometry/Geom.h"
+using namespace std;
+
+//
+// Interface0D
+//
+//////////////////////////////////////////////////
+
+class FEdge;
+class SVertex;
+class ViewVertex;
+class NonTVertex;
+class TVertex;
+/*! Base class for any 0D element. */
+class Interface0D
+{
+public:
+ 
+	virtual ~Interface0D() {}; //soc
+
+  /*! Returns the string "Interface0D".*/
+  virtual string getExactTypeName() const {
+    return "Interface0D";
+  }
+
+  // Data access methods
+
+  /*! Returns the 3D x coordinate of the point. */ 
+  virtual real getX() const {
+    cerr << "Warning: method getX() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the 3D y coordinate of the point. */ 
+  virtual real getY() const {
+    cerr << "Warning: method getY() not implemented" << endl;
+    return 0;
+  }
+
+  /*!  Returns the 3D z coordinate of the point. */ 
+  virtual real getZ() const {
+    cerr << "Warning: method getZ() not implemented" << endl;
+    return 0;
+  }
+
+  /*!  Returns the 3D point. */ 
+  virtual Geometry::Vec3f getPoint3D() const {
+    cerr << "Warning: method getPoint3D() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the 2D x coordinate of the point. */ 
+  virtual real getProjectedX() const {
+    cerr << "Warning: method getProjectedX() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the 2D y coordinate of the point. */ 
+  virtual real getProjectedY() const {
+    cerr << "Warning: method getProjectedY() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the 2D z coordinate of the point. */ 
+  virtual real getProjectedZ() const {
+    cerr << "Warning: method getProjectedZ() not implemented" << endl;
+    return 0;
+  }
+
+  /*!  Returns the 2D point. */ 
+  virtual Geometry::Vec2f getPoint2D() const {
+    cerr << "Warning: method getPoint2D() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the FEdge that lies between this Interface0D and the
+   *  Interface0D given as argument. */
+  virtual FEdge* getFEdge(Interface0D&) {
+    cerr << "Warning: method getFEdge() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the Id of the point. */ 
+  virtual Id getId() const {
+    cerr << "Warning: method getId() not implemented" << endl;
+    return Id(0, 0);
+  }
+
+  /*! Returns the nature of the point. */ 
+  virtual Nature::VertexNature getNature() const {
+    cerr << "Warning: method getNature() not implemented" << endl;
+    return Nature::POINT;
+  }
+
+  /*! Cast the Interface0D in SVertex if it can be. */ 
+  virtual SVertex * castToSVertex(){
+    cerr << "Warning: can't cast this Interface0D in SVertex" << endl;
+    return 0;
+  }
+
+  /*! Cast the Interface0D in ViewVertex if it can be. */ 
+  virtual ViewVertex * castToViewVertex(){
+    cerr << "Warning: can't cast this Interface0D in ViewVertex" << endl;
+    return 0;
+  }
+
+  /*! Cast the Interface0D in NonTVertex if it can be. */ 
+  virtual NonTVertex * castToNonTVertex(){
+    cerr << "Warning: can't cast this Interface0D in NonTVertex" << endl;
+    return 0;
+  }
+
+  /*! Cast the Interface0D in TVertex if it can be. */ 
+  virtual TVertex * castToTVertex(){
+    cerr << "Warning: can't cast this Interface0D in TVertex" << endl;
+    return 0;
+  }
+};
+
+
+//
+// Interface0DIteratorNested
+//
+//////////////////////////////////////////////////
+
+class Interface0DIteratorNested
+{
+public:
+
+  virtual ~Interface0DIteratorNested() {}
+
+  virtual string getExactTypeName() const {
+    return "Interface0DIteratorNested";
+  }
+
+  virtual Interface0D& operator*() = 0;
+
+  virtual Interface0D* operator->() {
+    return &(operator*());
+  }
+
+  virtual void increment() = 0;
+
+  virtual void decrement() = 0;
+
+  virtual bool isBegin() const = 0;
+
+  virtual bool isEnd() const = 0;
+
+  virtual bool operator==(const Interface0DIteratorNested& it) const = 0;
+
+  virtual bool operator!=(const Interface0DIteratorNested& it) const {
+    return !(*this == it);
+  }
+
+  /*! Returns the curvilinear abscissa */
+  virtual float t() const = 0;
+  /*! Returns the point parameter 0<u<1 */
+  virtual float u() const = 0;
+
+  virtual Interface0DIteratorNested* copy() const = 0;
+};
+
+
+//
+// Interface0DIterator
+//
+//////////////////////////////////////////////////
+
+/*! Class defining an iterator over Interface0D elements.
+ *  An instance of this iterator is always obtained
+ *  from a 1D element.
+ *  \attention In the scripting language, you must call
+ *  \code it2 = Interface0DIterator(it1) \endcode instead of \code it2 = it1 \endcode
+ *  where \a it1 and \a it2 are 2 Interface0DIterator.
+ *  Otherwise, incrementing \a it1 will also increment \a it2.
+ */
+class Interface0DIterator
+{
+public:
+
+  Interface0DIterator(Interface0DIteratorNested* it = NULL) {
+    _iterator = it;
+  }
+
+  /*! Copy constructor */
+  Interface0DIterator(const Interface0DIterator& it) {
+    _iterator = it._iterator->copy();
+  }
+
+  /*! Destructor */
+  virtual ~Interface0DIterator() {
+    if (_iterator)
+      delete _iterator;
+  }
+
+  /*! Operator =
+   *  \attention In the scripting language, you must call
+   *  \code it2 = Interface0DIterator(it1) \endcode instead of \code it2 = it1 \endcode
+   *  where \a it1 and \a it2 are 2 Interface0DIterator.
+   *  Otherwise, incrementing \a it1 will also increment \a it2.
+   */
+  Interface0DIterator& operator=(const Interface0DIterator& it) {
+    if(_iterator)
+      delete _iterator;
+    _iterator = it._iterator->copy();
+    return *this;
+  }
+
+  /*! Returns the string "Interface0DIterator". */
+  string getExactTypeName() const {
+    if (!_iterator)
+      return "Interface0DIterator";
+    return _iterator->getExactTypeName() + "Proxy";
+  }
+
+  // FIXME test it != 0 (exceptions ?)
+
+  /*! Returns a reference to the pointed Interface0D.
+   *  In the scripting language, you must call
+   *  "getObject()" instead using this operator.
+   */ 
+  Interface0D& operator*() {
+    return _iterator->operator*();
+  }
+
+  /*! Returns a pointer to the pointed Interface0D.
+   *  Can't be called in the scripting language.
+   */
+  Interface0D* operator->() {
+    return &(operator*());
+  }
+
+  /*! Increments. In the scripting language, call
+   *  "increment()".
+   */
+  Interface0DIterator& operator++() {
+    _iterator->increment();
+    return *this;
+  }
+
+  /*! Increments. In the scripting language, call
+   *  "increment()".
+   */
+  Interface0DIterator operator++(int) {
+    Interface0DIterator ret(*this);
+    _iterator->increment();
+    return ret;
+  }
+
+  /*! Decrements. In the scripting language, call
+   *  "decrement()".
+   */
+  Interface0DIterator& operator--() {
+    _iterator->decrement();
+    return *this;
+  }
+
+  /*! Decrements. In the scripting language, call
+   *  "decrement()".
+   */
+  Interface0DIterator operator--(int) {
+    Interface0DIterator ret(*this);
+    _iterator->decrement();
+    return ret;
+  }
+
+  /*! Increments. */
+  void increment() {
+    _iterator->increment();
+  }
+  
+  /*! Decrements. */
+  void decrement() {
+    _iterator->decrement();
+  }
+
+  /*! Returns true if the pointed Interface0D is the
+   * first of the 1D element containing the points over
+   * which we're iterating.
+   */
+  bool isBegin() const {
+    return _iterator->isBegin();
+  }
+
+  /*! Returns true if the pointed Interface0D is after the
+   * after the last point of the 1D element we're iterating from.
+   */
+  bool isEnd() const {
+    return _iterator->isEnd();
+  }
+
+  /*! operator == . */
+  bool operator==(const Interface0DIterator& it) const {
+    return _iterator->operator==(*(it._iterator));
+  }
+
+  /*! operator != . */
+  bool operator!=(const Interface0DIterator& it) const {
+    return !(*this == it);
+  }
+
+  /*! Returns the curvilinear abscissa. */
+  inline float t() const {
+    return _iterator->t();
+  }
+  /*! Returns the point parameter in the curve 0<=u<=1. */
+  inline float u() const {
+    return _iterator->u();
+  }
+protected:
+
+  Interface0DIteratorNested* _iterator;
+};
+
+#endif // INTERFACE0D_H
diff --git a/source/blender/freestyle/intern/view_map/Interface1D.h b/source/blender/freestyle/intern/view_map/Interface1D.h
new file mode 100755
index 00000000000..8c75afc73df
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Interface1D.h
@@ -0,0 +1,218 @@
+//
+//  Filename         : Interface1D.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Interface to 1D elts
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  INTERFACE1D_H
+# define INTERFACE1D_H
+
+# include <string>
+# include <iostream>
+# include <float.h>
+# include "../system/Id.h"
+# include "../system/Precision.h"
+# include "../winged_edge/Nature.h"
+# include "Functions0D.h"
+
+using namespace std;
+/*! \file Interface1D.h
+ *  Interface1D and related tools definitions
+ */
+// Integration method
+/*! The different integration
+ *  methods that can be invoked
+ *  to integrate into a single value the set of values obtained
+ *  from each 0D element of a 1D element.
+ */
+typedef enum {
+  MEAN,/*!< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/
+  MIN,/*!< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/
+  MAX,/*!< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/
+  FIRST,/*!< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/
+  LAST/*!< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/
+} IntegrationType;
+
+/*! Returns a single
+ *  value from a set of values evaluated at each 0D element
+ *  of this 1D element.
+ *  \param fun
+ *    The UnaryFunction0D used to compute a value at each Interface0D.
+ *  \param it
+ *    The Interface0DIterator used to iterate over the 0D elements of
+ *    this 1D element. The integration will occur over the 0D elements
+ *    starting from the one pointed by it.
+ *  \param it_end
+ *    The Interface0DIterator pointing the end of the 0D elements of the
+ *    1D element.
+ *  \param integration_type
+ *    The integration method used to compute a single value from
+ *    a set of values.
+ *  \return the single value obtained for the 1D element.
+ */
+template <class T>
+T integrate(UnaryFunction0D<T>& fun,
+	    Interface0DIterator it,
+	    Interface0DIterator it_end,
+	    IntegrationType integration_type = MEAN) {
+  T res;
+  T res_tmp;
+  unsigned size;
+  switch (integration_type) {
+  case MIN:
+    res = fun(it);++it;
+    for (; !it.isEnd(); ++it) {
+      res_tmp = fun(it);
+      if (res_tmp < res)
+	res = res_tmp;
+    }
+    break;
+  case MAX:
+    res = fun(it);++it;
+    for (; !it.isEnd(); ++it) {
+      res_tmp = fun(it);
+      if (res_tmp > res)
+	res = res_tmp;
+    }
+    break;
+  case FIRST:
+    res = fun(it);
+    break;
+  case LAST:
+    res = fun(--it_end);
+    break;
+  case MEAN:
+  default:
+    res = fun(it);++it;
+    for (size = 1; !it.isEnd(); ++it, ++size)
+      res += fun(it);
+    res /= (size ? size : 1);
+    break;
+  }
+  return res;
+}
+
+//
+// Interface1D
+//
+//////////////////////////////////////////////////
+
+/*! Base class for any 1D element. */
+class Interface1D
+{
+public:
+
+  /*! Default constructor */
+  Interface1D() {_timeStamp=0;}
+   virtual ~Interface1D() {}; //soc
+
+  /*! Returns the string "Interface1D" .*/
+  virtual string getExactTypeName() const {
+    return "Interface1D";
+  }
+
+  // Iterator access
+
+  /*! Returns an iterator over the Interface1D vertices,
+   *  pointing to the first vertex.
+   */
+  virtual Interface0DIterator verticesBegin() {
+	    cerr << "Warning: method verticesBegin() not implemented" << endl;
+	    return Interface0DIterator();
+  }
+	
+  /*! Returns an iterator over the Interface1D vertices,
+   *  pointing after the last vertex.
+   */
+  virtual Interface0DIterator verticesEnd(){
+	    cerr << "Warning: method verticesEnd() not implemented" << endl;
+	    return Interface0DIterator();
+  }
+
+  /*! Returns an iterator over the Interface1D points,
+   *  pointing to the first point. The difference with
+   *  verticesBegin() is that here we can iterate over
+   *  points of the 1D element at a any given sampling.
+   *  Indeed, for each iteration, a virtual point is created.
+   *  \param t
+   *    The sampling with which we want to iterate over points of
+   *    this 1D element.
+   */
+  virtual Interface0DIterator pointsBegin(float t=0.f) {
+	    cerr << "Warning: method pointsBegin() not implemented" << endl;
+	    return Interface0DIterator();
+  }
+
+  /*! Returns an iterator over the Interface1D points,
+   *  pointing after the last point. The difference with
+   *  verticesEnd() is that here we can iterate over
+   *  points of the 1D element at a any given sampling.
+   *  Indeed, for each iteration, a virtual point is created.
+   *  \param t
+   *    The sampling with which we want to iterate over points of
+   *    this 1D element.
+   */
+  virtual Interface0DIterator pointsEnd(float t=0.f) {
+	    cerr << "Warning: method pointsEnd() not implemented" << endl;
+	    return Interface0DIterator();
+  }
+
+  // Data access methods
+
+  /*! Returns the 2D length of the 1D element. */
+  virtual real getLength2D() const {
+    cerr << "Warning: method getLength2D() not implemented" << endl;
+    return 0;
+  }
+
+  /*! Returns the Id of the 1D element .*/
+  virtual Id getId() const {
+    cerr << "Warning: method getId() not implemented" << endl;
+    return Id(0, 0);
+  }
+
+  // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D)
+  /*! Returns the nature of the 1D element. */
+  virtual Nature::EdgeNature getNature() const {
+    cerr << "Warning: method getNature() not implemented" << endl;
+    return Nature::NO_FEATURE;
+  }
+  
+  /*! Returns the time stamp of the 1D element. Mainly used for selection. */
+  virtual unsigned getTimeStamp() const {
+    return _timeStamp;
+  }
+  
+  /*! Sets the time stamp for the 1D element. */
+  inline void setTimeStamp(unsigned iTimeStamp){
+    _timeStamp = iTimeStamp;
+  }
+
+protected:
+  unsigned _timeStamp;
+};
+
+#endif // INTERFACE1D_H
diff --git a/source/blender/freestyle/intern/view_map/Silhouette.cpp b/source/blender/freestyle/intern/view_map/Silhouette.cpp
new file mode 100755
index 00000000000..db4f82d369e
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Silhouette.cpp
@@ -0,0 +1,370 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "Silhouette.h"
+#include "ViewMap.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             SVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+Nature::VertexNature SVertex::getNature() const {
+  Nature::VertexNature nature = Nature::S_VERTEX;
+  if (_pViewVertex)
+    nature |= _pViewVertex->getNature();
+  return nature;
+}
+
+SVertex * SVertex::castToSVertex(){
+  return this;
+}
+
+ViewVertex * SVertex::castToViewVertex(){
+  return _pViewVertex;
+}
+
+NonTVertex * SVertex::castToNonTVertex(){
+  return dynamic_cast<NonTVertex*>(_pViewVertex);
+}
+
+TVertex * SVertex::castToTVertex(){
+  return dynamic_cast<TVertex*>(_pViewVertex);
+}
+
+float SVertex::shape_importance() const 
+{
+  return shape()->importance();
+}
+ 
+//Material SVertex::material() const {return _Shape->material();}
+Id SVertex::shape_id() const {return _Shape->getId();}
+const SShape *  SVertex::shape() const {return _Shape;}
+
+const int SVertex::qi() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->qi();
+}
+
+occluder_container::const_iterator SVertex::occluders_begin() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occluders_begin();
+}
+
+occluder_container::const_iterator SVertex::occluders_end() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occluders_end();
+}
+
+bool SVertex::occluders_empty() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occluders_empty();
+}
+
+int SVertex::occluders_size() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occluders_size();
+}
+
+const Polygon3r& SVertex::occludee() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occludee();
+}
+
+const SShape* SVertex::occluded_shape() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occluded_shape();
+}
+
+const bool  SVertex::occludee_empty() const
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->occludee_empty();
+}
+
+real SVertex::z_discontinuity() const 
+{
+  if (getNature() & Nature::T_VERTEX)
+    Exception::raiseException();
+  return (_FEdges[0])->z_discontinuity();
+}
+
+FEdge* SVertex::fedge()
+{
+  if (getNature() & Nature::T_VERTEX)
+    return 0;
+  return _FEdges[0];
+}
+
+FEdge* SVertex::getFEdge(Interface0D& inter)
+{
+  FEdge * result = 0;
+  SVertex* iVertexB = dynamic_cast<SVertex*>(&inter);
+  if (!iVertexB)
+    return result;
+  vector<FEdge*>::const_iterator fe=_FEdges.begin(), feend=_FEdges.end();
+  for(;
+  fe!=feend;
+  ++fe)
+  {
+    if(  (((*fe)->vertexA() == this) && ((*fe)->vertexB() == iVertexB))
+      || (((*fe)->vertexB() == this) && ((*fe)->vertexA() == iVertexB)))
+      result = (*fe);
+  }
+  if((result == 0) && (getNature() & Nature::T_VERTEX))
+  {
+    SVertex *brother;
+    ViewVertex *vvertex = viewvertex();
+    TVertex * tvertex = dynamic_cast<TVertex*>(vvertex);
+    if(tvertex)
+    {
+      brother = tvertex->frontSVertex();
+      if(this == brother)
+        brother = tvertex->backSVertex();
+      const vector<FEdge*>& fedges = brother->fedges();
+      for(fe=fedges.begin(),feend=fedges.end();
+      fe!=feend;
+      ++fe)
+      {
+        if(  (((*fe)->vertexA() == brother) && ((*fe)->vertexB() == iVertexB))
+          || (((*fe)->vertexB() == brother) && ((*fe)->vertexA() == iVertexB)))
+        result = (*fe);
+      }
+    }
+  }
+  if((result == 0) && (iVertexB->getNature() & Nature::T_VERTEX))
+  {
+    SVertex *brother;
+    ViewVertex *vvertex = iVertexB->viewvertex();
+    TVertex * tvertex = dynamic_cast<TVertex*>(vvertex);
+    if(tvertex)
+    {
+      brother = tvertex->frontSVertex();
+      if(iVertexB == brother)
+        brother = tvertex->backSVertex();
+      for(fe=_FEdges.begin(),feend=_FEdges.end();
+      fe!=feend;
+      ++fe)
+      {
+        if(  (((*fe)->vertexA() == this) && ((*fe)->vertexB() == brother))
+          || (((*fe)->vertexB() == this) && ((*fe)->vertexA() == brother)))
+        result = (*fe);
+      }
+    }
+  }
+  
+  return result;
+}
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             FEdge              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+int FEdge::viewedge_nature() const {return _ViewEdge->getNature();}
+//float FEdge::viewedge_length() const {return _ViewEdge->viewedge_length();}
+const SShape* FEdge::occluded_shape() const 
+{
+  ViewShape * aShape = _ViewEdge->aShape(); 
+  if(aShape == 0) 
+    return 0;
+  return aShape->sshape();
+}
+
+float FEdge::shape_importance() const 
+{
+  return _VertexA->shape()->importance();
+} 
+
+int FEdge::invisibility() const 
+{
+  return _ViewEdge->qi();
+}
+
+occluder_container::const_iterator FEdge::occluders_begin() const {return _ViewEdge->occluders_begin();}
+occluder_container::const_iterator FEdge::occluders_end() const {return _ViewEdge->occluders_end();}
+bool FEdge::occluders_empty() const {return _ViewEdge->occluders_empty();}
+int FEdge::occluders_size() const {return _ViewEdge->occluders_size();}
+const bool  FEdge::occludee_empty() const
+{
+  return _ViewEdge->occludee_empty();
+}
+
+
+
+Id FEdge::shape_id() const 
+{
+  return _VertexA->shape()->getId();
+}
+const SShape* FEdge::shape() const 
+{
+  return _VertexA->shape();
+}
+
+real FEdge::z_discontinuity() const 
+{
+  if(!(getNature() & Nature::SILHOUETTE) && !(getNature() & Nature::BORDER))
+  {
+    return 0;
+  }
+
+  BBox<Vec3r> box = ViewMap::getInstance()->getScene3dBBox();
+
+  Vec3r bbox_size_vec(box.getMax() - box.getMin());
+  real bboxsize = bbox_size_vec.norm();
+  if(occludee_empty())
+
+  {
+    //return FLT_MAX;
+
+    return 1.0;
+
+    //return bboxsize;
+
+  }
+  //  real result;
+  //  z_discontinuity_functor<SVertex> _functor;
+
+  //  Evaluate<SVertex,z_discontinuity_functor<SVertex> >(&_functor, iCombination, result )
+  Vec3r middle((_VertexB->point3d()-_VertexA->point3d()));
+
+  middle /= 2;
+  Vec3r disc_vec(middle - _occludeeIntersection);
+  real res = disc_vec.norm() / bboxsize;
+  return res;
+  
+  //return fabs((middle.z()-_occludeeIntersection.z()));
+}
+
+
+//float FEdge::local_average_depth(int iCombination ) const 
+//{
+//
+//  float result;
+//  local_average_depth_functor<SVertex> functor;
+//  Evaluate(&functor, iCombination, result);
+//
+//  return result;
+//}
+//float FEdge::local_depth_variance(int iCombination ) const
+//{
+//  float result;
+//
+//  local_depth_variance_functor<SVertex> functor;
+//
+//  Evaluate(&functor, iCombination, result);
+//
+//  return result;
+//}
+//
+//
+//real FEdge::local_average_density( float sigma, int iCombination) const 
+//{
+//  float result;
+//
+//  density_functor<SVertex> functor(sigma);
+//
+//  Evaluate(&functor, iCombination, result);
+//
+//  return result;
+//}
+//
+////Vec3r FEdge::normal(int& oException /* = Exception::NO_EXCEPTION */)
+////{
+////  Vec3r Na = _VertexA->normal(oException);
+////  if(oException != Exception::NO_EXCEPTION)
+////    return Na;
+////  Vec3r Nb = _VertexB->normal(oException);
+////  if(oException != Exception::NO_EXCEPTION)
+////    return Nb;
+////  return (Na+Nb)/2.0;
+////}  
+//
+//Vec3r FEdge::curvature2d_as_vector(int iCombination) const 
+//{
+//  Vec3r result;
+//  curvature2d_as_vector_functor<SVertex> _functor;
+//  Evaluate<Vec3r,curvature2d_as_vector_functor<SVertex> >(&_functor, iCombination, result );
+//  return result;
+//}
+//
+//real FEdge::curvature2d_as_angle(int iCombination) const 
+//{
+//  real result;
+//  curvature2d_as_angle_functor<SVertex> _functor;
+//  Evaluate<real,curvature2d_as_angle_functor<SVertex> >(&_functor, iCombination, result );
+//  return result;
+//}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             FEdgeSharp        */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+//Material FEdge::material() const 
+//{
+//  return _VertexA->shape()->material();
+//}
+const Material& FEdgeSharp::aMaterial() const {
+  return _VertexA->shape()->material(_aMaterialIndex);
+}
+
+const Material& FEdgeSharp::bMaterial() const {
+  return _VertexA->shape()->material(_bMaterialIndex);
+}
+
+                 /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             FEdgeSmooth         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+const Material& FEdgeSmooth::material() const {
+  return _VertexA->shape()->material(_MaterialIndex);
+}
diff --git a/source/blender/freestyle/intern/view_map/Silhouette.h b/source/blender/freestyle/intern/view_map/Silhouette.h
new file mode 100755
index 00000000000..c88a3da8967
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Silhouette.h
@@ -0,0 +1,1419 @@
+//
+//  Filename         : Silhouette.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes to define a silhouette structure
+//  Date of creation : 25/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SILHOUETTE_H
+# define SILHOUETTE_H
+
+# include <iostream>
+# include <string>
+# include <vector>
+# include <set>
+# include <float.h>
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+# include "../geometry/BBox.h"
+# include "../scene_graph/Material.h"
+# include "../geometry/Polygon.h"
+# include "../system/Exception.h"
+# include "Interface0D.h"
+# include "Interface1D.h"
+# include "../winged_edge/Curvature.h"
+
+using namespace std;
+using namespace Geometry;
+
+class ViewShape;
+typedef vector<ViewShape*> occluder_container;
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             SVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+class FEdge;
+class ViewVertex;
+class SShape;
+
+/*! Class to define a vertex of the embedding. */
+class LIB_VIEW_MAP_EXPORT SVertex : public Interface0D
+{
+public: // Implementation of Interface0D
+
+  /*! Returns the string "SVertex" .*/
+  virtual string getExactTypeName() const {
+    return "SVertex";
+  }
+
+  // Data access methods
+
+  /*! Returns the 3D x coordinate of the vertex .*/
+  virtual real getX() const {
+    return _Point3D.x();
+  }
+
+  /*! Returns the 3D y coordinate of the vertex .*/
+  virtual real getY() const {
+    return _Point3D.y();
+  }
+
+  /*! Returns the 3D z coordinate of the vertex .*/
+  virtual real getZ() const {
+    return _Point3D.z();
+  }
+
+  /*!  Returns the 3D point. */ 
+  virtual Vec3f getPoint3D() const {
+    return _Point3D;
+  }
+
+  /*! Returns the projected 3D  x coordinate of the vertex .*/
+  virtual real getProjectedX() const {
+    return _Point2D.x();
+  }
+
+  /*! Returns the projected 3D  y coordinate of the vertex .*/
+  virtual real getProjectedY() const {
+    return _Point2D.y();
+  }
+
+  /*! Returns the projected 3D  z coordinate of the vertex .*/
+  virtual real getProjectedZ() const {
+    return _Point2D.z();
+  }
+
+  /*!  Returns the 2D point. */ 
+  virtual Vec2f getPoint2D() const {
+    return Vec2f((float)_Point2D.x(),(float)_Point2D.y());
+  }
+
+  /*! Returns the FEdge that lies between this Svertex and the
+   *  Interface0D given as argument. */
+  virtual FEdge* getFEdge(Interface0D&);
+
+  /*! Returns the Id of the vertex .*/
+  virtual Id getId() const {
+    return _Id;
+  }
+
+  /*! Returns the nature of the vertex .*/
+  virtual Nature::VertexNature getNature() const;
+
+  /*! Cast the Interface0D in SVertex if it can be. */ 
+  virtual SVertex * castToSVertex();
+
+  /*! Cast the Interface0D in ViewVertex if it can be. */ 
+  virtual ViewVertex * castToViewVertex();
+
+  /*! Cast the Interface0D in NonTVertex if it can be. */ 
+  virtual NonTVertex * castToNonTVertex();
+
+  /*! Cast the Interface0D in TVertex if it can be. */ 
+  virtual TVertex * castToTVertex();
+
+public:
+
+  typedef vector<FEdge*> fedges_container;
+
+private:
+
+  Id _Id;
+  Vec3r _Point3D;
+  Vec3r _Point2D;
+  set<Vec3r> _Normals; 
+  vector<FEdge*> _FEdges; // the edges containing this vertex
+  SShape *_Shape;  // the shape to which belongs the vertex
+  ViewVertex *_pViewVertex; // The associated viewvertex, in case there is one.
+  real _curvatureFredo;
+  Vec2r _directionFredo;
+  CurvatureInfo* _curvature_info;
+
+public:
+
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void *userdata;
+
+  /*! Default constructor.*/
+  inline SVertex() {
+    _Id = 0;
+    userdata = NULL;
+    _Shape = NULL;
+    _pViewVertex = 0;
+    _curvature_info = 0;
+  }
+
+  /*! Builds a SVertex from 3D coordinates and an Id. */
+  inline SVertex(const Vec3r &iPoint3D, const Id& id) {
+    _Point3D = iPoint3D;
+    _Id=id;
+    userdata = NULL;
+    _Shape = NULL;
+    _pViewVertex=0;
+    _curvature_info = 0;
+  }
+
+  /*! Copy constructor. */
+  inline SVertex(SVertex& iBrother) {
+    _Id = iBrother._Id;
+    _Point3D =  iBrother.point3D();
+    _Point2D = iBrother.point2D();
+    _Normals = iBrother._Normals;
+    _FEdges = iBrother.fedges();
+    _Shape = iBrother.shape();
+    _pViewVertex = iBrother._pViewVertex;
+    if (!(iBrother._curvature_info))
+      _curvature_info = 0;
+    else
+      _curvature_info = new CurvatureInfo(*(iBrother._curvature_info));
+    iBrother.userdata = this;
+    userdata = 0;
+  }
+
+  /*! Destructor. */
+  virtual ~SVertex() {
+    if (_curvature_info)
+      delete _curvature_info;
+  }
+
+  /*! Cloning method. */
+  virtual SVertex * duplicate() {
+    SVertex *clone = new SVertex(*this);
+    return clone;
+  }
+
+  /*! operator == */
+  virtual bool operator==(const SVertex& iBrother) {
+    return ((_Point2D == iBrother._Point2D) &&
+	    (_Point3D == iBrother._Point3D));
+  }
+
+  /* accessors */
+  inline const Vec3r& point3D() const {return _Point3D;}
+  inline const Vec3r& point2D() const {return _Point2D;}
+  /*! Returns the set of normals for this Vertex.
+   *  In a smooth surface, a vertex has exactly one normal.
+   *  In a sharp surface, a vertex can have any number of normals.
+   */
+  inline set<Vec3r> normals() {return _Normals;}
+  /*! Returns the number of different normals for this vertex. */
+  inline unsigned normalsSize() const {return _Normals.size();}
+  inline const vector<FEdge*>& fedges() {return _FEdges;}
+  inline fedges_container::iterator fedges_begin() {return _FEdges.begin();}
+  inline fedges_container::iterator fedges_end() {return _FEdges.end();}
+  inline SShape * shape() {return _Shape;}
+  inline real z() const {return _Point2D[2];}
+  /*! If this SVertex is also a ViewVertex, this method
+   *  returns a pointer onto this ViewVertex. 0 is returned
+   *  otherwise.
+   */
+  inline ViewVertex * viewvertex() {return _pViewVertex;}
+
+  /*! modifiers */
+  /*! Sets the 3D coordinates of the SVertex. */
+  inline void setPoint3D(const Vec3r &iPoint3D) {_Point3D = iPoint3D;}
+  /*! Sets the 3D projected coordinates of the SVertex. */
+  inline void setPoint2D(const Vec3r &iPoint2D) {_Point2D = iPoint2D;}
+  /*! Adds a normal to the Svertex's set of normals. If the same
+   * normal is already in the set, nothing changes.
+   */
+  inline void AddNormal(const Vec3r& iNormal) 
+  {
+    _Normals.insert(iNormal); // if iNormal in the set already exists, nothing is done
+  }
+
+  void setCurvatureInfo(CurvatureInfo* ci) {
+    _curvature_info = ci;
+  }
+
+  const CurvatureInfo* getCurvatureInfo() const {
+    return _curvature_info;
+  }
+
+  /* Fredo's normal and curvature*/
+  void setCurvatureFredo(real c) {_curvatureFredo=c;}
+  void setDirectionFredo(Vec2r d) {_directionFredo=d;}
+  real curvatureFredo () {return _curvatureFredo;}
+  const Vec2r directionFredo () {return _directionFredo;}
+
+  /*! Sets the Id */
+  inline void setId(const Id& id) {_Id = id;}
+  inline void setFEdges(const vector<FEdge*>& iFEdges) {_FEdges = iFEdges;}
+  inline void setShape(SShape *iShape) {_Shape = iShape;}
+  inline void setViewVertex(ViewVertex *iViewVertex) {_pViewVertex = iViewVertex;}
+  /*! Add an FEdge to the list of edges emanating from this SVertex. */
+  inline void AddFEdge(FEdge* iFEdge) {_FEdges.push_back(iFEdge);}
+  /* replaces edge 1 by edge 2 in the list of edges */
+  inline void Replace(FEdge *e1, FEdge *e2)
+  {
+    vector<FEdge*>::iterator insertedfe;
+    for(vector<FEdge*>::iterator fe=_FEdges.begin(),fend=_FEdges.end();
+        fe!=fend;
+        fe++)
+      {
+        if((*fe) == e1)
+          {
+            insertedfe = _FEdges.insert(fe, e2);// inserts e2 before fe.
+                                                // returns an iterator pointing toward e2. fe is invalidated.
+            // we want to remove e1, but we can't use fe anymore:
+            insertedfe++; // insertedfe points now to e1
+            _FEdges.erase(insertedfe);
+            return;
+          }
+      }
+  }
+
+public:
+
+  /* Information access interface */
+
+  FEdge *fedge() ; // for non T vertex
+  inline const Vec3r& point2d() const {return point2D();}
+  inline const Vec3r& point3d() const {return point3D();}
+  inline Vec3r normal() const {if(_Normals.size() == 1) return (*(_Normals.begin())); Exception::raiseException(); return *(_Normals.begin());}
+  //Material material() const ;
+  Id shape_id() const ;
+  const SShape* shape() const ;
+  float shape_importance() const ;
+  
+  const int qi() const ;
+  occluder_container::const_iterator occluders_begin() const ;
+  occluder_container::const_iterator occluders_end() const ;
+  bool occluders_empty() const ;
+  int occluders_size() const ;
+  const Polygon3r& occludee() const ;
+  const SShape * occluded_shape() const ;
+  const bool  occludee_empty() const ;
+  real z_discontinuity() const ;
+  //inline float local_average_depth() const ;
+  //  inline float local_depth_variance() const ;
+  //  inline real local_average_density(float sigma = 2.3f) const ;
+  //inline Vec3r shaded_color() const ;
+  //  inline Vec3r orientation2d() const ; 
+  //  inline Vec3r orientation3d() const ;
+  //  inline Vec3r curvature2d_as_vector() const ;
+  /*! angle in radians */
+  //  inline real curvature2d_as_angle() const ;
+  
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             FEdge              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+class ViewEdge;
+/*! Base Class for feature edges.
+ *  This FEdge can represent a silhouette, a crease,
+ *  a ridge/valley, a border or a suggestive contour.
+ *  For silhouettes,  the FEdge is oriented
+ *  such as, the visible face lies on the left of the edge.
+ *  For borders, the FEdge is oriented
+ *  such as, the face lies on the left of the edge.
+ *  An FEdge can represent an initial edge of the mesh
+ *  or runs accross a face of the initial mesh depending
+ *  on the smoothness or sharpness of the mesh.
+ *  This class is specialized into a smooth and a sharp
+ *  version since their properties slightly vary from
+ *  one to the other.
+ */
+class LIB_VIEW_MAP_EXPORT FEdge : public Interface1D
+{
+public: // Implementation of Interface0D
+
+  /*! Returns the string "FEdge" . */
+  virtual string getExactTypeName() const {
+    return "FEdge";
+  }
+
+  // Data access methods
+
+  /*! Returns the 2D length of the FEdge. */
+  virtual real getLength2D() const {
+    if (!_VertexA || !_VertexB)
+      return 0;
+    return (_VertexB->getPoint2D() - _VertexA->getPoint2D()).norm();
+  }
+
+  /*! Returns the Id of the FEdge. */
+  virtual Id getId() const {
+    return _Id;
+  }
+
+public:
+
+  // An edge can only be of one kind (SILHOUETTE or BORDER, etc...)
+  // For an multi-nature edge there must be several different FEdge.
+   // DEBUG:
+  //  Vec3r A;
+  //  Vec3r u;
+  //  vector<Polygon3r> _Occludees;
+  //  Vec3r intersection;
+  //  vector<Vec3i> _Cells;
+
+protected:
+  SVertex *_VertexA;
+  SVertex *_VertexB;
+  Id _Id;
+  Nature::EdgeNature _Nature;
+  //vector<Polygon3r> _Occluders; // visibility // NON GERE PAR LE COPY CONSTRUCTOR!!
+  
+  FEdge *_NextEdge; // next edge on the chain
+  FEdge *_PreviousEdge;
+  ViewEdge *_ViewEdge;
+  // Sometimes we need to deport the visibility computation onto another 
+  // edge. For example the exact edges use edges of the mesh to 
+  // compute their visibility
+  
+  Polygon3r _aFace; // The occluded face which lies on the right of a silhouette edge
+  Vec3r _occludeeIntersection;
+  bool _occludeeEmpty;
+
+  bool _isSmooth;
+
+public:
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void *userdata;
+  /*! Default constructor */
+  inline FEdge() {
+    userdata = NULL;
+    _VertexA = NULL;
+    _VertexB = NULL;
+    _Nature = Nature::NO_FEATURE;
+    _NextEdge = NULL;
+    _PreviousEdge = NULL;
+    _ViewEdge = NULL;
+    //_hasVisibilityPoint=false;
+    _occludeeEmpty = true;
+    _isSmooth = false;
+  }
+  /*! Builds an FEdge going from vA to vB. */  
+  inline FEdge(SVertex *vA, SVertex *vB) {
+    userdata = NULL;
+    _VertexA = vA;
+    _VertexB = vB;
+    _Nature = Nature::NO_FEATURE;
+    _NextEdge=NULL;
+    _PreviousEdge=NULL;
+    _ViewEdge = NULL;
+    //_hasVisibilityPoint=false;
+    _occludeeEmpty = true;
+    _isSmooth = false;
+  }
+  /*! Copy constructor */
+  inline FEdge(FEdge& iBrother)
+  {
+    _VertexA = iBrother.vertexA();
+    _VertexB = iBrother.vertexB();
+    _NextEdge = iBrother.nextEdge();
+    _PreviousEdge = iBrother._PreviousEdge;
+    _Nature = iBrother.getNature();
+    _Id = iBrother._Id;
+    _ViewEdge = iBrother._ViewEdge;
+    //_hasVisibilityPoint = iBrother._hasVisibilityPoint;
+    //_VisibilityPointA = iBrother._VisibilityPointA;
+    //_VisibilityPointB = iBrother._VisibilityPointB;
+    _aFace = iBrother._aFace;
+    _occludeeEmpty = iBrother._occludeeEmpty;
+    _isSmooth = iBrother._isSmooth;
+    iBrother.userdata = this;
+    userdata = 0;
+  }
+  /*! Destructor */
+  virtual ~FEdge() {}
+  /*! Cloning method. */
+  virtual FEdge* duplicate()
+  {
+    FEdge *clone = new FEdge(*this);
+    return clone;
+  }
+  /* accessors */
+  /*! Returns the first SVertex. */
+  inline SVertex* vertexA() {return _VertexA;}
+  /*! Returns the second SVertex. */
+  inline SVertex* vertexB() {return _VertexB;}
+  /*! Returns the first SVertex if i=0, the seccond SVertex
+   *  if i=1. */
+  inline SVertex* operator[](const unsigned short int& i) const{ 
+      return i%2==0 ? _VertexA : _VertexB;
+  }
+  /*! Returns the nature of the FEdge. */
+  inline Nature::EdgeNature getNature() const {return _Nature;}
+  /*! Returns the FEdge following this one in the ViewEdge.
+   *  If this FEdge is the last of the ViewEdge, 0 is returned.
+   */
+  inline FEdge * nextEdge() {return _NextEdge;}
+  /*! Returns the Edge preceding this one in the ViewEdge.
+   *  If this FEdge is the first one of the ViewEdge, 0 is returned.
+   */
+  inline FEdge * previousEdge() {return _PreviousEdge;}
+  inline SShape * shape() {return _VertexA->shape();}
+  //inline int invisibility() const {return _Occluders.size();}
+  int invisibility() const ;
+  //inline const vector<Polygon3r>& occluders() const {return _Occluders;}
+  /*! Returns a pointer to the ViewEdge to which this FEdge belongs to. */
+  inline ViewEdge * viewedge() const {return _ViewEdge;}
+  inline Vec3r center3d() {return Vec3r((_VertexA->point3D()+_VertexB->point3D())/2.0);}
+  inline Vec3r center2d() {return Vec3r((_VertexA->point2D()+_VertexB->point2D())/2.0);}
+  //  inline bool hasVisibilityPoint() const {return _hasVisibilityPoint;}
+  //  inline Vec3r visibilityPointA() const {return _VisibilityPointA;}
+  //  inline Vec3r visibilityPointB() const {return _VisibilityPointB;}
+  inline const Polygon3r& aFace() const {return _aFace;}
+  inline const Vec3r& getOccludeeIntersection() { return _occludeeIntersection; }
+  inline bool getOccludeeEmpty() { return _occludeeEmpty; }
+  /*! Returns true if this FEdge is a smooth FEdge. */
+  inline bool isSmooth() const {return _isSmooth;}
+
+  /* modifiers */
+  /*! Sets the first SVertex. */
+  inline void setVertexA(SVertex *vA) {_VertexA = vA;}
+  /*! Sets the second SVertex. */
+  inline void setVertexB(SVertex *vB) {_VertexB = vB;}
+  /*! Sets the FEdge Id . */
+  inline void setId(const Id& id) {_Id = id;}
+  /*! Sets the pointer to the next FEdge. */
+  inline void setNextEdge(FEdge* iEdge) {_NextEdge = iEdge;}
+  /*! Sets the pointer to the previous FEdge. */
+  inline void setPreviousEdge(FEdge *iEdge) {_PreviousEdge = iEdge;}
+  /*! Sets the nature of this FEdge. */
+  inline void setNature(Nature::EdgeNature iNature) {_Nature = iNature;}
+  //inline void AddOccluder(Polygon3r& iPolygon) {_Occluders.push_back(iPolygon);}
+  /*! Sets the ViewEdge to which this FEdge belongs to. */
+  inline void setViewEdge(ViewEdge *iViewEdge) {_ViewEdge = iViewEdge;}
+  //  inline void setHasVisibilityPoint(bool iBool) {_hasVisibilityPoint = iBool;}
+  //  inline void setVisibilityPointA(const Vec3r& iPoint) {_VisibilityPointA = iPoint;}
+  //  inline void setVisibilityPointB(const Vec3r& iPoint) {_VisibilityPointB = iPoint;}
+  inline void setaFace(Polygon3r& iFace) {_aFace = iFace;}
+  inline void setOccludeeIntersection(const Vec3r& iPoint) {_occludeeIntersection = iPoint;}
+  inline void setOccludeeEmpty(bool iempty) {_occludeeEmpty = iempty;}
+  /*! Sets the flag telling whether this FEdge is smooth or sharp.
+   *  true for Smooth, false for Sharp.
+   */
+  inline void setSmooth(bool iFlag) {_isSmooth = iFlag;}
+  
+  /* checks whether two FEdge have a common vertex.
+   *  Returns a pointer on the common vertex if it exists, 
+   *  NULL otherwise.
+   */
+  static inline SVertex* CommonVertex(FEdge *iEdge1, FEdge* iEdge2)
+  {
+    if((NULL == iEdge1) || (NULL == iEdge2))
+      return NULL;
+
+    SVertex *sv1 = iEdge1->vertexA();
+    SVertex *sv2 = iEdge1->vertexB();
+    SVertex *sv3 = iEdge2->vertexA();
+    SVertex *sv4 = iEdge2->vertexB();
+
+    if((sv1 == sv3) || (sv1 == sv4))
+    {
+      return sv1;
+    }
+    else if((sv2 == sv3) || (sv2 == sv4))
+    {
+      return sv2;
+    }
+
+    return NULL;
+  }
+
+  inline const SVertex* min2d() const 
+  {
+    if(_VertexA->point2D() < _VertexB->point2D())
+      return _VertexA;
+    else
+      return _VertexB;
+  }
+  inline const SVertex* max2d() const 
+  {
+    if(_VertexA->point2D() < _VertexB->point2D())
+      return _VertexB;
+    else
+      return _VertexA;
+  }
+ 
+  /* Information access interface */
+  /* Information access interface */
+ 
+  //Material material() const ;
+  Id shape_id() const ;
+  const SShape * shape() const ;
+  float shape_importance() const ;
+  inline const int qi() const {return invisibility();}
+  occluder_container::const_iterator occluders_begin() const ;
+  occluder_container::const_iterator occluders_end() const ;
+  bool occluders_empty() const ;
+  int occluders_size() const ;
+  inline const Polygon3r& occludee() const {return aFace();}
+  const SShape * occluded_shape() const ;
+  //inline const bool  occludee_empty() const {return _occludeeEmpty;}
+  const bool  occludee_empty() const ;
+  real z_discontinuity() const ;
+  //  inline float local_average_depth(int iCombination = 0) const ;
+  //  inline float local_depth_variance(int iCombination = 0) const ;
+  //  inline real local_average_density(float sigma = 2.3f, int iCombination = 0) const ;
+  //inline Vec3r shaded_color(int iCombination = 0) const {}
+  int viewedge_nature() const ;
+  //float viewedge_length() const ;
+  inline Vec3r orientation2d() const {return Vec3r(_VertexB->point2d()-_VertexA->point2d());}
+  inline Vec3r orientation3d() const {return Vec3r(_VertexB->point3d()-_VertexA->point3d());}
+  //  //inline real curvature2d() const {return viewedge()->curvature2d((_VertexA->point2d()+_VertexB->point2d())/2.0);}
+  //  inline Vec3r curvature2d_as_vector(int iCombination = 0) const ;
+  //  /* angle in degrees*/
+  //  inline real curvature2d_as_angle(int iCombination = 0) const ;  
+
+
+  // Iterator access (Interface1D)
+  /*! Returns an iterator over the 2 (!) SVertex
+   *  pointing to the first SVertex. */
+  virtual inline Interface0DIterator verticesBegin();
+  /*! Returns an iterator over the 2 (!) SVertex
+   *  pointing after the last SVertex. */
+  virtual inline Interface0DIterator verticesEnd();
+
+  /*! Returns an iterator over the FEdge points,
+   *  pointing to the first point. The difference with
+   *  verticesBegin() is that here we can iterate over
+   *  points of the FEdge at a any given sampling.
+   *  Indeed, for each iteration, a virtual point is created.
+   *  \param t
+   *    The sampling with which we want to iterate over points of
+   *    this FEdge.
+   */
+  virtual inline Interface0DIterator pointsBegin(float t=0.f);
+  /*! Returns an iterator over the FEdge points,
+   *  pointing after the last point. The difference with
+   *  verticesEnd() is that here we can iterate over
+   *  points of the FEdge at a any given sampling.
+   *  Indeed, for each iteration, a virtual point is created.
+   *  \param t
+   *    The sampling with which we want to iterate over points of
+   *    this FEdge.
+   */
+  virtual inline Interface0DIterator pointsEnd(float t=0.f);
+};
+
+//
+// SVertexIterator
+//
+/////////////////////////////////////////////////
+
+namespace FEdgeInternal {
+
+  class SVertexIterator : public Interface0DIteratorNested
+  {
+  public:
+
+    SVertexIterator() {
+      _vertex = NULL;
+      _edge = NULL;
+    }
+
+    SVertexIterator(const SVertexIterator& vi) {
+      _vertex = vi._vertex;
+      _edge = vi._edge;
+    }
+
+    SVertexIterator(SVertex* v, FEdge* edge) {
+      _vertex = v;
+      _edge = edge;
+    }
+
+    SVertexIterator& operator=(const SVertexIterator& vi) {
+      _vertex = vi._vertex;
+      _edge = vi._edge;
+      return *this;
+    }
+
+    virtual string getExactTypeName() const {
+      return "SVertexIterator";
+    }
+
+    virtual SVertex& operator*() {
+      return *_vertex;
+    }
+
+    virtual SVertex* operator->() {
+      return &(operator*());
+    }
+
+    virtual SVertexIterator& operator++() {
+      increment();
+      return *this;
+    }
+
+    virtual SVertexIterator operator++(int) {
+      SVertexIterator ret(*this);
+      increment();
+      return ret;
+    }
+
+    virtual SVertexIterator& operator--() {
+      decrement();
+      return *this;
+    }
+
+    virtual SVertexIterator operator--(int) {
+      SVertexIterator ret(*this);
+      decrement();
+      return ret;
+    }
+
+    virtual void increment() {
+      if (_vertex == _edge->vertexB()) {
+	_vertex = 0;
+	return;
+      }
+
+      _vertex = _edge->vertexB();
+    }
+
+    virtual void decrement() {
+      if (_vertex == _edge->vertexA()) {
+	_vertex = 0;
+	return;
+      }
+      _vertex = _edge->vertexA();
+    }
+
+    virtual bool isBegin() const {
+      return _vertex == _edge->vertexA();
+    }
+
+    virtual bool isEnd() const {
+      return _vertex == _edge->vertexB();
+    }
+
+    virtual bool operator==(const Interface0DIteratorNested& it) const {
+      const SVertexIterator* it_exact = dynamic_cast<const SVertexIterator*>(&it);
+      if (!it_exact)
+	return false;
+      return ((_vertex == it_exact->_vertex) &&
+	      (_edge == it_exact->_edge));
+    }
+
+    virtual float t() const{
+      if(_vertex == _edge->vertexA()){
+        return 0;
+      }
+      return ((float)_edge->getLength2D());
+    }
+    virtual float u() const{
+      if(_vertex == _edge->vertexA()){
+        return 0;
+      }
+      return 1.0;
+    }
+    virtual SVertexIterator* copy() const {
+      return new SVertexIterator(*this);
+    }
+
+  private:
+
+    SVertex*	_vertex;
+    FEdge*	_edge;
+  };
+
+} // end of namespace FEdgeInternal
+
+// Iterator access (implementation)
+
+Interface0DIterator FEdge::verticesBegin() {
+  Interface0DIterator ret(new FEdgeInternal::SVertexIterator(_VertexA, this));
+  return ret;
+}
+
+Interface0DIterator FEdge::verticesEnd() {
+  Interface0DIterator ret(new FEdgeInternal::SVertexIterator(0, this));
+  return ret;
+}
+
+Interface0DIterator FEdge::pointsBegin(float t) {
+  return verticesBegin();
+}
+
+Interface0DIterator FEdge::pointsEnd(float t) {
+  return verticesEnd();
+}
+
+/*! Class defining a sharp FEdge. A Sharp FEdge
+ *  corresponds to an initial edge of the input mesh.
+ *  It can be a silhouette, a crease or a border.
+ *  If it is a crease edge, then it is borded
+ *  by two faces of the mesh. Face a lies on its right
+ *  whereas Face b lies on its left.
+ *  If it is a border edge, then it doesn't have any
+ *  face on its right, and thus Face a = 0.
+ */
+class LIB_VIEW_MAP_EXPORT FEdgeSharp : public FEdge
+{
+protected:
+  Vec3r _aNormal; // When following the edge, normal of the right face
+  Vec3r _bNormal; // When following the edge, normal of the left face
+  unsigned _aMaterialIndex;
+  unsigned _bMaterialIndex;
+  
+public:
+  /*! Default constructor. */
+  inline FEdgeSharp() : FEdge(){
+    _aMaterialIndex = _bMaterialIndex = 0;
+  }
+  /*! Builds an FEdgeSharp going from vA to vB. */ 
+  inline FEdgeSharp(SVertex *vA, SVertex *vB) : FEdge(vA, vB){
+    _aMaterialIndex = _bMaterialIndex = 0;
+  }
+  /*! Copy constructor. */
+  inline FEdgeSharp(FEdgeSharp& iBrother) : FEdge(iBrother){
+    _aNormal = iBrother._aNormal;
+    _bNormal = iBrother._bNormal;
+    _aMaterialIndex = iBrother._aMaterialIndex;
+    _bMaterialIndex = iBrother._bMaterialIndex;
+  }
+  /*! Destructor. */
+  virtual ~FEdgeSharp() {}
+  /*! Cloning method. */
+  virtual FEdge* duplicate(){
+    FEdge *clone = new FEdgeSharp(*this);
+    return clone;
+  }
+  /*! Returns the normal to the face lying on the
+   *  right of the FEdge. If this FEdge is a border,
+   *  it has no Face on its right and therefore, no normal.
+   */
+  inline const Vec3r& normalA() {return _aNormal;}
+  /*! Returns the normal to the face lying on the
+   *  left of the FEdge.
+   */
+  inline const Vec3r& normalB() {return _bNormal;}
+  /*! Returns the index of the material of the face lying on the
+   *  right of the FEdge. If this FEdge is a border,
+   *  it has no Face on its right and therefore, no material.
+   */
+  inline unsigned aMaterialIndex() const {return _aMaterialIndex;}
+  /*! Returns the material of the face lying on the
+   *  right of the FEdge. If this FEdge is a border,
+   *  it has no Face on its right and therefore, no material.
+   */
+  const Material& aMaterial() const ;
+  /*! Returns the index of the material of the face lying on the
+   *  left of the FEdge.
+   */
+  inline unsigned bMaterialIndex() const {return _bMaterialIndex;}
+  /*! Returns the  material of the face lying on the
+   *  left of the FEdge.
+   */
+  const Material& bMaterial() const ;
+
+  /*! Sets the normal to the face lying on the right of the FEdge. */
+  inline void setNormalA(const Vec3r& iNormal) {_aNormal = iNormal;}
+  /*! Sets the normal to the face lying on the left of the FEdge. */ 
+  inline void setNormalB(const Vec3r& iNormal) {_bNormal = iNormal;}
+  /*! Sets the index of the material lying on the right of the FEdge.*/
+  inline void setaMaterialIndex(unsigned i) {_aMaterialIndex = i;}
+  /*! Sets the index of the material lying on the left of the FEdge.*/
+  inline void setbMaterialIndex(unsigned i) {_bMaterialIndex = i;}
+  
+};
+
+/*! Class defining a smooth edge. This kind of edge typically
+ *  runs across a face of the input mesh. It can be
+ *  a silhouette, a ridge or valley, a suggestive contour.
+ */
+class LIB_VIEW_MAP_EXPORT FEdgeSmooth : public FEdge
+{
+protected:
+  Vec3r _Normal;
+  unsigned _MaterialIndex;
+  //  bool _hasVisibilityPoint;
+  //  Vec3r _VisibilityPointA;  // The edge on which the visibility will be computed represented 
+  //  Vec3r _VisibilityPointB;  // using its 2 extremity points A and B
+  void * _Face; // In case of exact silhouette, Face is the WFace crossed by Fedge 
+               // NON GERE PAR LE COPY CONSTRUCTEUR
+public:
+  /*! Default constructor. */
+  inline FEdgeSmooth() : FEdge(){
+    _Face=0;
+    _MaterialIndex = 0;
+    _isSmooth = true;
+  }
+  /*! Builds an FEdgeSmooth going from vA to vB. */  
+  inline FEdgeSmooth(SVertex *vA, SVertex *vB) : FEdge(vA, vB){
+    _Face=0;
+    _MaterialIndex = 0;
+    _isSmooth = true;
+
+  }
+  /*! Copy constructor. */
+  inline FEdgeSmooth(FEdgeSmooth& iBrother) : FEdge(iBrother){
+    _Normal = iBrother._Normal;
+    _Face = iBrother._Face;
+    _MaterialIndex = iBrother._MaterialIndex;
+    _isSmooth = true;
+  }
+  /*! Destructor. */
+  virtual ~FEdgeSmooth() {}
+  /*! Cloning method. */
+  virtual FEdge* duplicate(){
+    FEdge *clone = new FEdgeSmooth(*this);
+    return clone;
+  }
+
+  inline void * face() const {return _Face;}
+  /*! Returns the normal to the Face it is running accross. */
+  inline const Vec3r& normal() {return _Normal;}
+  /*! Returns the index of the material of the face it is running accross. */
+  inline unsigned materialIndex() const {return _MaterialIndex;}
+  /*! Returns the material of the face it is running accross. */
+  const Material& material() const ;
+
+  inline void setFace(void * iFace) {_Face = iFace;}
+  /*! Sets the normal to the Face it is running accross. */
+  inline void setNormal(const Vec3r& iNormal) {_Normal = iNormal;}
+  /*! Sets the index of the material of the face it is running accross. */
+  inline void setMaterialIndex(unsigned i) {_MaterialIndex = i;}
+};
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             SShape             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+/*! Class to define a feature shape. It is the gathering 
+ *  of feature elements from an identified input shape
+ */
+class LIB_VIEW_MAP_EXPORT SShape
+{
+private:
+  vector<FEdge*> _chains;          // list of fedges that are chains starting points.
+  vector<SVertex*> _verticesList;  // list of all vertices
+  vector<FEdge*>   _edgesList;     // list of all edges
+  Id _Id;
+  BBox<Vec3r> _BBox;
+  vector<Material> _Materials;  
+
+  float _importance;
+
+  ViewShape *_ViewShape;
+
+public:
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void* userdata; // added by E.T.
+  /*! Default constructor */
+  inline SShape()
+  {
+    userdata = 0;
+
+    _importance = 0.f;
+    _ViewShape = 0;
+  }
+  /*! Copy constructor */
+  inline SShape(SShape& iBrother)
+  {
+    userdata = 0;
+    _Id = iBrother._Id;
+    _BBox = iBrother.bbox();
+    _Materials = iBrother._Materials;
+
+    _importance = iBrother._importance;
+
+    _ViewShape = iBrother._ViewShape;
+
+     
+    //---------
+    // vertices
+    //---------
+    vector<SVertex*>::iterator sv,svend;
+    vector<SVertex*>& verticesList = iBrother.GetVertexList();
+    for(sv=verticesList.begin(), svend=verticesList.end();
+        sv!=svend;
+        sv++)
+      {
+        SVertex *newv = new SVertex(*(*sv));
+        newv->setShape(this);
+        _verticesList.push_back(newv);
+      }
+    
+    //------
+    // edges
+    //------
+    vector<FEdge*>::iterator e,eend;
+    vector<FEdge*>& edgesList = iBrother.GetEdgeList();
+    for(e=edgesList.begin(),eend=edgesList.end();
+        e!=eend;
+        e++)
+      {
+        FEdge *newe = (*e)->duplicate();
+        _edgesList.push_back(newe);
+      } 
+
+        //-------------------------
+        // starting chain edges
+        //-------------------------
+        vector<FEdge*>::iterator fe,fend;
+        vector<FEdge*>& fedges = iBrother.GetChains();
+        for(fe=fedges.begin(),fend=fedges.end();
+        fe!=fend;
+        fe++)
+        {
+          _chains.push_back((FEdge*)((*fe)->userdata));
+        }
+        
+    
+    //-------------------------
+    // remap edges in vertices:
+    //-------------------------
+    for(sv=_verticesList.begin(),svend=_verticesList.end();
+        sv!=svend;
+        sv++)
+      {
+        const vector<FEdge*>& fedgeList = (*sv)->fedges();
+        vector<FEdge*> newfedgelist;
+        for(vector<FEdge*>::const_iterator fed=fedgeList.begin(),fedend=fedgeList.end();
+            fed!=fedend;
+            fed++)
+          {
+            FEdge *current = *fed;
+            newfedgelist.push_back((FEdge*)current->userdata);
+          }
+        (*sv)->setFEdges(newfedgelist); 
+      }
+    
+    //-------------------------------------
+    // remap vertices and nextedge in edges:
+    //-------------------------------------
+    for(e=_edgesList.begin(),eend=_edgesList.end();
+        e!=eend;
+        e++)
+      {
+        (*e)->setVertexA((SVertex*)((*e)->vertexA()->userdata));
+        (*e)->setVertexB((SVertex*)((*e)->vertexB()->userdata));
+        (*e)->setNextEdge((FEdge*)((*e)->nextEdge()->userdata));
+        (*e)->setPreviousEdge((FEdge*)((*e)->previousEdge()->userdata));
+      }
+    
+
+    // reset all brothers userdata to NULL:
+    //-------------------------------------
+    //---------
+    // vertices
+    //---------
+    for(sv=_verticesList.begin(),svend=_verticesList.end();
+        sv!=svend;
+        sv++)
+      {
+        (*sv)->userdata = NULL;
+      }
+
+    //------
+    // edges
+    //------
+    for(e=_edgesList.begin(),eend=_edgesList.end();
+        e!=eend;
+        e++)
+      {
+        (*e)->userdata = NULL;
+      }  
+  }
+  /*! Cloning method. */
+  virtual SShape * duplicate()
+  {
+    SShape *clone = new SShape(*this);
+    return clone;
+  }
+  /*! Destructor. */
+  virtual inline ~SShape()
+  {
+    vector<SVertex*>::iterator sv,svend;
+    vector<FEdge*>::iterator e,eend;
+    if(0 != _verticesList.size())
+      {
+        for(sv=_verticesList.begin(),svend=_verticesList.end();
+            sv!=svend;
+            sv++)
+          {
+            delete (*sv);
+          }
+        _verticesList.clear();
+      }
+
+    if(0 != _edgesList.size())
+      {
+        for(e=_edgesList.begin(),eend=_edgesList.end();
+            e!=eend;
+            e++)
+          {
+            delete (*e);
+          }
+        _edgesList.clear();
+      }
+
+    //! Clear the chains list
+    //-----------------------
+    if(0 != _chains.size())
+      {
+        _chains.clear();
+      }
+  }
+
+  /*! Adds a FEdge to the list of FEdges. */
+  inline void AddEdge(FEdge *iEdge)
+    {
+      _edgesList.push_back(iEdge);
+    }
+
+  /*! Adds a SVertex to the list of SVertex of this Shape.
+   * The SShape attribute of the SVertex is also set to 'this'.
+   */
+  inline void AddNewVertex(SVertex* iv) {iv->setShape(this);_verticesList.push_back(iv);}
+  inline void AddChain(FEdge *iEdge){
+    _chains.push_back(iEdge);
+  }
+
+  inline SVertex * CreateSVertex(const Vec3r& P3D, const Vec3r& P2D, const Id& id)
+  {
+    SVertex *Ia = new SVertex(P3D, id);
+    Ia->setPoint2D(P2D);
+    AddNewVertex(Ia);
+    return Ia;
+  }
+  /* splits an edge into several edges. 
+   *  The edge's vertices are passed rather than 
+   *  the edge itself. This way, all feature edges (SILHOUETTE,
+   *  CREASE, BORDER) are splitted in the same time.
+   *  The processed edges are flagged as done (using the userdata
+   *  flag).One single new vertex is created whereas 
+   *  several splitted edges might created for the different 
+   *  kinds of edges. These new elements are added to the lists
+   *  maintained by the shape.
+   *  new chains are also created.
+   *    ioA
+   *      The first vertex for the edge that gets splitted
+   *    ioB
+   *      The second vertex for the edge that gets splitted
+   *    iParameters
+   *      A vector containing 2D real vectors indicating the parameters
+   *      giving the intersections coordinates in 3D and in 2D.
+   *      These intersections points must be sorted from B to A.
+   *      Each parameter defines the intersection point I as I=A+T*AB.
+   *      T<0 and T>1 are then incorrect insofar as they give intersections
+   *      points that lie outside the segment.
+   *    ioNewEdges
+   *      The edges that are newly created (the initial edges are not 
+   *      included) are added to this list.
+   */
+  inline void SplitEdge(FEdge *fe, const vector<Vec2r>& iParameters, vector<FEdge*>& ioNewEdges)
+    {
+    
+    SVertex *ioA = fe->vertexA();
+    SVertex *ioB = fe->vertexB();
+    Vec3r A = ioA->point3D();
+    Vec3r B = ioB->point3D();
+    Vec3r a = ioA->point2D();
+    Vec3r b = ioB->point2D();
+    SVertex *svA, *svB;
+
+    Vec3r newpoint3d,newpoint2d;
+    vector<SVertex*> intersections;
+    real t,T;
+    for(vector<Vec2r>::const_iterator p=iParameters.begin(),pend=iParameters.end();
+    p!=pend;
+    p++)
+    {
+      T=(*p)[0];
+      t=(*p)[1];
+
+      if((t < 0) || (t > 1))
+        cerr << "Warning: Intersection out of range for edge " << ioA->getId() << " - " << ioB->getId() << endl;
+    
+      // compute the 3D and 2D coordinates for the intersections points:
+      newpoint3d = Vec3r(A + T*(B-A));
+      newpoint2d = Vec3r(a + t*(b-a));
+
+      // create new SVertex:
+      // (we keep B's id)
+      SVertex* newVertex = new SVertex(newpoint3d, ioB->getId());
+      newVertex->setPoint2D(newpoint2d);
+      
+      // Add this vertex to the intersections list:
+      intersections.push_back(newVertex);
+
+      // Add this vertex to this sshape:
+      AddNewVertex(newVertex);
+    }
+    
+    for(vector<SVertex*>::iterator sv=intersections.begin(),svend=intersections.end();
+    sv!=svend;
+    sv++)
+    {
+      svA = fe->vertexA();
+      svB = fe->vertexB();
+        
+      // We split edge AB into AA' and A'B. A' and A'B are created.
+      // AB becomes (address speaking) AA'. B is updated.
+      //--------------------------------------------------
+      // The edge AB becomes edge AA'.
+      (fe)->setVertexB((*sv));
+      // a new edge, A'B is created.
+      FEdge *newEdge;
+      if(fe->isSmooth()){
+        newEdge = new FEdgeSmooth((*sv), svB);
+        FEdgeSmooth * se = dynamic_cast<FEdgeSmooth*>(newEdge);
+        FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+        se->setMaterialIndex(fes->materialIndex());
+      }else{
+        newEdge = new FEdgeSharp((*sv), svB);
+        FEdgeSharp * se = dynamic_cast<FEdgeSharp*>(newEdge);
+        FEdgeSharp * fes = dynamic_cast<FEdgeSharp*>(fe);
+        se->setaMaterialIndex(fes->aMaterialIndex());
+        se->setbMaterialIndex(fes->bMaterialIndex());
+      }
+        
+      newEdge->setNature((fe)->getNature());
+      
+
+      // to build a new chain:
+      AddChain(newEdge);
+      // add the new edge to the sshape edges list.
+      AddEdge(newEdge);
+      // add new edge to the list of new edges passed as argument:
+      ioNewEdges.push_back(newEdge);
+
+      // update edge A'B for the next pointing edge
+      newEdge->setNextEdge((fe)->nextEdge());
+      fe->nextEdge()->setPreviousEdge(newEdge);
+      Id id(fe->getId().getFirst(), fe->getId().getSecond()+1);
+      newEdge->setId(fe->getId());
+      fe->setId(id);
+
+      // update edge AA' for the next pointing edge
+      //ioEdge->setNextEdge(newEdge);
+      (fe)->setNextEdge(NULL);
+
+      // update vertex pointing edges list:
+      // -- vertex B --
+      svB->Replace((fe), newEdge);
+      // -- vertex A' --
+      (*sv)->AddFEdge((fe));
+      (*sv)->AddFEdge(newEdge);
+    }
+          
+    }
+
+  /* splits an edge into 2 edges. The new vertex and edge are added
+   *  to the sshape list of vertices and edges
+   *  a new chain is also created.
+   *  returns the new edge.
+   *    ioEdge
+   *      The edge that gets splitted
+   *    newpoint
+   *      x,y,z coordinates of the new point.
+   */
+  inline FEdge* SplitEdgeIn2(FEdge* ioEdge, SVertex * ioNewVertex)
+    {
+      //soc unused - SVertex *A = ioEdge->vertexA();
+      SVertex *B = ioEdge->vertexB();
+
+      
+      // We split edge AB into AA' and A'B. A' and A'B are created.
+      // AB becomes (address speaking) AA'. B is updated.
+      //--------------------------------------------------
+      
+      // a new edge, A'B is created.
+      FEdge *newEdge;
+      if(ioEdge->isSmooth()){
+        newEdge = new FEdgeSmooth(ioNewVertex, B);
+        FEdgeSmooth * se = dynamic_cast<FEdgeSmooth*>(newEdge);
+        FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(ioEdge);
+        se->setMaterialIndex(fes->materialIndex());
+      }else{
+        newEdge = new FEdgeSharp(ioNewVertex, B);
+        FEdgeSharp * se = dynamic_cast<FEdgeSharp*>(newEdge);
+        FEdgeSharp * fes = dynamic_cast<FEdgeSharp*>(ioEdge);
+        se->setaMaterialIndex(fes->aMaterialIndex());
+        se->setbMaterialIndex(fes->bMaterialIndex());
+      }
+      newEdge->setNature(ioEdge->getNature());
+      
+      
+      if(ioEdge->nextEdge() != 0)
+        ioEdge->nextEdge()->setPreviousEdge(newEdge);
+
+      // update edge A'B for the next pointing edge
+      newEdge->setNextEdge(ioEdge->nextEdge());
+      // update edge A'B for the previous pointing edge
+      newEdge->setPreviousEdge(0); // because it is now a TVertex
+      Id id(ioEdge->getId().getFirst(), ioEdge->getId().getSecond()+1);
+      newEdge->setId(ioEdge->getId());
+      ioEdge->setId(id);
+   
+      // update edge AA' for the next pointing edge
+      ioEdge->setNextEdge(0); // because it is now a TVertex
+
+      // update vertex pointing edges list:
+      // -- vertex B --
+      B->Replace(ioEdge, newEdge);
+      // -- vertex A' --
+      ioNewVertex->AddFEdge(ioEdge);
+      ioNewVertex->AddFEdge(newEdge);
+
+      // to build a new chain:
+      AddChain(newEdge);
+      AddEdge(newEdge); // FIXME ??
+      
+      // The edge AB becomes edge AA'.
+      ioEdge->setVertexB(ioNewVertex);
+      
+      if(ioEdge->isSmooth()){
+        ((FEdgeSmooth*)newEdge)->setFace(((FEdgeSmooth*)ioEdge)->face());
+      }
+      
+      return newEdge;
+    }
+
+  /*! Sets the Bounding Box of the Shape */
+  inline void setBBox(const BBox<Vec3r>& iBBox) {_BBox = iBBox;}
+
+  /*! Compute the bbox of the sshape */
+  inline void ComputeBBox()
+  {
+    if(0 == _verticesList.size())
+      return;
+
+    Vec3r firstVertex = _verticesList[0]->point3D();
+    real XMax = firstVertex[0];
+    real YMax = firstVertex[1];
+    real ZMax = firstVertex[2];
+
+    real XMin = firstVertex[0];
+    real YMin = firstVertex[1];
+    real ZMin = firstVertex[2];
+
+    vector<SVertex*>::iterator v,vend;
+    // parse all the coordinates to find 
+    // the Xmax, YMax, ZMax
+    for(v=_verticesList.begin(),vend=_verticesList.end();
+        v!=vend;
+        v++)
+      {
+        Vec3r vertex = (*v)->point3D();
+        // X
+        real x = vertex[0];
+        if(x > XMax)
+          XMax = x;
+        if(x < XMin)
+          XMin = x;
+        
+        // Y
+        real y = vertex[1];
+        if(y > YMax)
+          YMax = y;
+        if(y < YMin)
+          YMin = y;
+        
+        // Z
+        real z = vertex[2];
+        if(z > ZMax)
+          ZMax = z;
+        if(z < ZMin)
+          ZMin = z;
+      }
+    
+    
+    setBBox(BBox<Vec3r>(Vec3r(XMin, YMin, ZMin), Vec3r(XMax, YMax, ZMax)));
+  }
+
+  inline void RemoveEdgeFromChain(FEdge *iEdge)
+  {
+    for(vector<FEdge*>::iterator fe=_chains.begin(), feend=_chains.end();
+    fe!=feend;
+    fe++)
+    {
+      if(iEdge == (*fe))
+      {
+        _chains.erase(fe);
+        break;
+      }
+    }
+  }
+
+  inline void RemoveEdge(FEdge *iEdge)
+  {
+    for(vector<FEdge*>::iterator fe=_edgesList.begin(), feend=_edgesList.end();
+    fe!=feend;
+    fe++)
+    {
+      if(iEdge == (*fe))
+      {
+        _edgesList.erase(fe);
+        break;
+      }
+    }
+  }
+
+  /* accessors */
+  /*! Returns the list of SVertex of the Shape. */
+  inline vector<SVertex*>& GetVertexList() {return _verticesList;} // Get vertices list
+  /*! Returns the list of FEdges of the Shape. */
+  inline vector<FEdge*>& GetEdgeList() {return _edgesList;} // Get edges list
+  inline vector<FEdge*>& GetChains() {return _chains;}
+  /*! Returns the bounding box of the shape. */
+  inline const BBox<Vec3r>& bbox() {return _BBox;}
+  /*! Returns the ith material of the shape. */
+  inline const Material& material(unsigned i) const {return _Materials[i];}
+  /*! Returns the list of materials of the Shape. */
+  inline const vector<Material>& materials() const {return _Materials;}
+  inline ViewShape * viewShape() {return _ViewShape;}
+  inline float importance() const {return _importance;}
+  /*! Returns the Id of the Shape. */
+  inline Id getId() const { return _Id; }
+  
+  /* Modififers */
+  /*! Sets the Id of the shape.*/
+  inline void setId(Id id) {_Id = id;}
+  /*! Sets the list of materials for the shape */
+  inline void setMaterials(const vector<Material>& iMaterials) {_Materials = iMaterials;}
+  inline void setViewShape(ViewShape *iShape) {_ViewShape = iShape;}
+  inline void setImportance(float importance){_importance = importance;}
+};
+
+#endif // SILHOUETTE_H
diff --git a/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp
new file mode 100755
index 00000000000..33c1115e94f
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp
@@ -0,0 +1,185 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SilhouetteGeomEngine.h"
+#include "Silhouette.h"
+#include "../geometry/GeomUtils.h"
+
+using namespace std;
+
+Vec3r SilhouetteGeomEngine::_Viewpoint = Vec3r(0,0,0);
+real SilhouetteGeomEngine::_translation[3] = {0,0,0};
+real SilhouetteGeomEngine::_modelViewMatrix[4][4] = {{1,0,0,0},
+						     {0,1,0,0},
+						     {0,0,1,0},
+						     {0,0,0,1}};
+real SilhouetteGeomEngine::_projectionMatrix[4][4] = {{1,0,0,0},
+						     {0,1,0,0},
+						     {0,0,1,0},
+						     {0,0,0,1}};
+real SilhouetteGeomEngine::_transform[4][4] = {{1,0,0,0},
+					       {0,1,0,0},
+					       {0,0,1,0},
+					       {0,0,0,1}};
+int SilhouetteGeomEngine::_viewport[4] = {1,1,1,1};              // the viewport
+real SilhouetteGeomEngine::_Focal = 0.0;
+  
+real SilhouetteGeomEngine::_glProjectionMatrix[4][4] = {{1,0,0,0},
+							{0,1,0,0},
+							{0,0,1,0},
+							{0,0,0,1}};
+real SilhouetteGeomEngine::_glModelViewMatrix[4][4] = {{1,0,0,0},
+						       {0,1,0,0},
+						       {0,0,1,0},
+						       {0,0,0,1}};
+real SilhouetteGeomEngine::_znear = 0.0;
+real SilhouetteGeomEngine::_zfar = 100.0;
+  
+SilhouetteGeomEngine * SilhouetteGeomEngine::_pInstance = 0;
+
+void SilhouetteGeomEngine::setTransform(const real iModelViewMatrix[4][4], const real iProjectionMatrix[4][4], const int iViewport[4], real iFocal) 
+{
+  unsigned int i,j;
+  _translation[0] = iModelViewMatrix[3][0];
+  _translation[1] = iModelViewMatrix[3][1];
+  _translation[2] = iModelViewMatrix[3][2];
+  
+  for(i=0; i<4; i++){
+    for(j=0; j<4; j++)
+    {
+      _modelViewMatrix[i][j] = iModelViewMatrix[j][i];
+      _glModelViewMatrix[i][j] = iModelViewMatrix[i][j];
+    }
+  }
+
+  for(i=0; i<4; i++){
+    for(j=0; j<4; j++)
+    {
+      _projectionMatrix[i][j] = iProjectionMatrix[j][i];
+      _glProjectionMatrix[i][j] = iProjectionMatrix[i][j];
+    }
+  }
+      
+  for(i=0; i<4; i++){
+    for(j=0; j<4; j++)
+    {
+      _transform[i][j] = 0;
+      for(unsigned int k=0; k<4; k++)
+        _transform[i][j] += _projectionMatrix[i][k] * _modelViewMatrix[k][j];
+    }
+  }
+      
+  for(i=0; i<4; i++){
+    _viewport[i] = iViewport[i];
+  }
+  _Focal = iFocal;
+}
+
+void SilhouetteGeomEngine::setFrustum(real iZNear, real iZFar) 
+{
+  _znear = iZNear;
+  _zfar = iZFar;
+}
+
+void SilhouetteGeomEngine::retrieveViewport(int viewport[4]){
+  memcpy(viewport, _viewport, 4*sizeof(int));
+}
+//#define HUGE 1e9
+
+void SilhouetteGeomEngine::ProjectSilhouette(vector<SVertex*>& ioVertices)
+{
+  Vec3r newPoint;
+  //  real min=HUGE;
+  //  real max=-HUGE;
+  vector<SVertex*>::iterator sv, svend;
+  
+  for(sv=ioVertices.begin(), svend=ioVertices.end();
+      sv!=svend;
+      sv++)
+    {
+      GeomUtils::fromWorldToImage((*sv)->point3D(), newPoint, _modelViewMatrix, _projectionMatrix, _viewport);
+      newPoint[2] = (-newPoint[2]-_znear)/(_zfar-_znear); // normalize Z between 0 and 1
+      (*sv)->setPoint2D(newPoint);  
+      //cerr << (*sv)->point2d().z() << "  ";
+      //      real d=(*sv)->point2d()[2];
+      //      if (d>max) max =d;
+      //      if (d<min) min =d;
+    }
+      //  for(sv=ioVertices.begin(), svend=ioVertices.end();
+      //      sv!=svend;
+      //      sv++)
+      //    {
+      //      Vec3r P((*sv)->point2d());
+      //      (*sv)->setPoint2D(Vec3r(P[0], P[1], 1.0-(P[2]-min)/(max-min)));
+      //      //cerr<<(*sv)->point2d()[2]<<"  ";
+      //    }
+}
+
+void SilhouetteGeomEngine::ProjectSilhouette(SVertex* ioVertex)
+{
+  Vec3r newPoint;
+  //  real min=HUGE;
+  //  real max=-HUGE;
+  vector<SVertex*>::iterator sv, svend;
+  GeomUtils::fromWorldToImage(ioVertex->point3D(), newPoint, _modelViewMatrix, _projectionMatrix, _viewport);
+  newPoint[2] = (-newPoint[2]-_znear)/(_zfar-_znear); // normalize Z between 0 and 1
+  ioVertex->setPoint2D(newPoint);  
+}
+
+real SilhouetteGeomEngine::ImageToWorldParameter(FEdge *fe, real t)
+{
+  // we need to compute for each parameter t the corresponding 
+  // parameter T which gives the intersection in 3D.
+  //currentEdge = (*fe);
+  Vec3r A = (fe)->vertexA()->point3D();
+  Vec3r B = (fe)->vertexB()->point3D();
+  Vec3r Ai = (fe)->vertexA()->point2D();
+  Vec3r Bi = (fe)->vertexB()->point2D();
+  Vec3r AB = Vec3r((B-A)); // the edge
+  Vec3r ABi(Bi-Ai);
+  Vec3r Ac, Bc;
+  GeomUtils::fromWorldToCamera(A, Ac, _modelViewMatrix);
+  GeomUtils::fromWorldToCamera(B, Bc, _modelViewMatrix);
+      
+  Vec3r Ii = Vec3r((Ai+t*ABi)); // I image
+  // let us compute the 3D point corresponding to the 2D intersection point
+  // and lying on the edge:
+  Vec3r Ir, Ic;
+  GeomUtils::fromImageToRetina(Ii, Ir, _viewport);
+  GeomUtils::fromRetinaToCamera(Ir, Ic, -_Focal, _projectionMatrix);
+  
+  real T;
+  T = (Ic[2]*Ac[1] - Ic[1]*Ac[2])/(Ic[1]*(Bc[2]-Ac[2])-Ic[2]*(Bc[1]-Ac[1]));
+  
+  return T;
+}
+
+Vec3r SilhouetteGeomEngine::WorldToImage(const Vec3r& M)
+
+{
+
+  Vec3r newPoint;
+  GeomUtils::fromWorldToImage(M, newPoint, _transform, _viewport);
+  newPoint[2] = (-newPoint[2]-_znear)/(_zfar-_znear); // normalize Z between 0 and 1
+  return newPoint;
+
+}
+
diff --git a/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h
new file mode 100755
index 00000000000..9638d26986f
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h
@@ -0,0 +1,122 @@
+//
+//  Filename         : SilhouetteGeomEngine.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to perform all geometric operations dedicated 
+//                     to silhouette. That, for example, implies that
+//                     this geom engine has as member data the viewpoint, 
+//                     transformations, projections...
+//  Date of creation : 03/09/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  SILHOUETTEGEOMENGINE_H
+# define SILHOUETTEGEOMENGINE_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+
+using namespace Geometry;
+
+class SVertex;
+class FEdge;
+
+class LIB_VIEW_MAP_EXPORT SilhouetteGeomEngine 
+{
+private:
+  static Vec3r _Viewpoint;   // The viewpoint under which the silhouette has to be computed
+  static real _translation[3];
+  static real _modelViewMatrix[4][4];  // the model view matrix (_modelViewMatrix[i][j] means element of line i and column j)
+  static real _projectionMatrix[4][4]; // the projection matrix (_projectionMatrix[i][j] means element of line i and column j)
+  static real _transform[4][4];        // the global transformation from world to screen (projection included) (_transform[i][j] means element of line i and column j)
+  static int _viewport[4];              // the viewport
+  static real _Focal;
+  
+  static real _znear;
+  static real _zfar;
+
+  static real _glProjectionMatrix[4][4];  // GL style (column major) projection matrix
+  static real _glModelViewMatrix[4][4];  // GL style (column major) model view matrix
+
+  
+  
+  static SilhouetteGeomEngine *_pInstance;
+public:
+  
+  /*! retrieves an instance on the singleton */
+  static SilhouetteGeomEngine * getInstance() 
+  {
+    if(0 == _pInstance)
+    {
+      _pInstance = new SilhouetteGeomEngine;
+    }
+    return _pInstance;
+  }
+
+  /*! Sets the current viewpoint */
+  static inline void setViewpoint(const Vec3r& ivp) {_Viewpoint = ivp;}
+
+  /*! Sets the current transformation
+   *    iModelViewMatrix
+   *      The 4x4 model view matrix, in column major order (openGL like).
+   *    iProjection matrix
+   *      The 4x4 projection matrix, in column major order (openGL like).
+   *    iViewport
+   *      The viewport. 4 real array: origin.x, origin.y, width, length
+   *    iFocal
+   *      The focal length
+   */
+  static void setTransform(const real iModelViewMatrix[4][4], const real iProjectionMatrix[4][4], const int iViewport[4], real iFocal) ;  
+
+  /*! Sets the current znear and zfar
+   */
+  static void setFrustum(real iZNear, real iZFar) ;  
+
+  /* accessors */
+  static void retrieveViewport(int viewport[4]);
+
+  /*! Projects the silhouette in camera coordinates
+   *  This method modifies the ioEdges passed as argument.
+   *    ioVertices
+   *      The vertices to project. It is modified during the 
+   *      operation.
+   */
+  static void ProjectSilhouette(std::vector<SVertex*>& ioVertices);  
+  static void ProjectSilhouette(SVertex* ioVertex);
+
+  /*! transforms the parameter t defining a 2D intersection for edge fe in order to obtain 
+   *  the parameter giving the corresponding 3D intersection.
+   *  Returns the 3D parameter
+   *    fe
+   *      The edge
+   *    t
+   *      The parameter for the 2D intersection.
+   */
+  static real ImageToWorldParameter(FEdge *fe, real t);
+
+  /*! From world to image */
+  static Vec3r WorldToImage(const Vec3r& M);
+};
+
+#endif // SILHOUETTEGEOMENGINE_H
diff --git a/source/blender/freestyle/intern/view_map/SteerableViewMap.cpp b/source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
new file mode 100755
index 00000000000..13c6bd65312
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
@@ -0,0 +1,268 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SteerableViewMap.h"
+#include "../image/ImagePyramid.h"
+#include "../image/Image.h"
+#include "Silhouette.h"
+#include <math.h>
+#include "../geometry/Geom.h"
+using namespace Geometry;
+
+//soc #include <qstring.h>
+//soc #include <qimage.h>
+#include <sstream>
+
+extern "C" {
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+#include "intern/IMB_png.h"
+}
+
+SteerableViewMap::SteerableViewMap(unsigned int nbOrientations){
+  _nbOrientations = nbOrientations;
+  _bound = cos(M_PI/(float)_nbOrientations);
+  for(unsigned i=0; i<_nbOrientations; ++i){
+    _directions.push_back(Vec2d(cos((float)i*M_PI/(float)_nbOrientations), sin((float)i*M_PI/(float)_nbOrientations)));
+  }
+  Build();
+}
+
+void SteerableViewMap::Build(){
+  _imagesPyramids = new ImagePyramid*[_nbOrientations+1]; // one more map to store the complete visible VM
+  memset((_imagesPyramids),0,(_nbOrientations+1)*sizeof(ImagePyramid*));
+}
+
+SteerableViewMap::SteerableViewMap(const SteerableViewMap& iBrother){
+  _nbOrientations = iBrother._nbOrientations;
+  unsigned i;
+  _bound = iBrother._bound;
+  _directions = iBrother._directions;
+  _mapping = iBrother._mapping;
+  _imagesPyramids = new ImagePyramid*[_nbOrientations+1]; // one more map to store the complete visible VM
+  for(i=0;i<_nbOrientations+1;++i)
+    _imagesPyramids[i] = new GaussianPyramid(*(dynamic_cast<GaussianPyramid*>(iBrother._imagesPyramids[i])));
+}
+
+SteerableViewMap::~SteerableViewMap(){
+  Clear(); 
+}
+
+void SteerableViewMap::Clear(){
+  unsigned i;
+  if(_imagesPyramids){
+    for(i=0; i<=_nbOrientations; ++i){
+      if(_imagesPyramids[i])
+        delete (_imagesPyramids)[i];
+    } 
+    delete [] _imagesPyramids;
+    _imagesPyramids = 0;
+  } 
+  if(!_mapping.empty()){
+    for(map<unsigned int, double*>::iterator m=_mapping.begin(), mend=_mapping.end(); 
+    m!=mend;
+    ++m){
+      delete [] (*m).second;
+    }
+    _mapping.clear();
+  }
+}
+
+void SteerableViewMap::Reset(){
+  Clear();
+  Build();
+}
+
+double SteerableViewMap::ComputeWeight(const Vec2d& dir, unsigned i){ 
+  double dotp = fabs(dir*_directions[i]);
+  if(dotp < _bound)
+    return 0;
+  if(dotp>1)
+    dotp = 1;
+
+  return cos((float)_nbOrientations/2.0*acos(dotp));
+}
+
+double * SteerableViewMap::AddFEdge(FEdge *iFEdge){
+  unsigned i;
+  unsigned id = iFEdge->getId().getFirst();
+  map<unsigned int, double* >::iterator o = _mapping.find(id);
+  if(o!=_mapping.end()){
+    return (*o).second;
+  }
+  double * res = new double[_nbOrientations];
+  for(i=0; i<_nbOrientations; ++i){
+    res[i] = 0;
+  }
+  Vec3r o2d3 = iFEdge->orientation2d();
+  Vec2r o2d2(o2d3.x(), o2d3.y());
+  real norm = o2d2.norm();
+  if(norm < 1e-6){
+    return res;
+  }
+  o2d2/=norm;
+
+  for(i=0; i<_nbOrientations; ++i){
+    res[i] = ComputeWeight(o2d2, i);
+  }
+  _mapping[id] = res;
+  return res;
+}
+
+unsigned SteerableViewMap::getSVMNumber(const Vec2f& orient){
+  Vec2f dir(orient);
+  //soc unsigned res = 0;
+  real norm = dir.norm();
+  if(norm < 1e-6){
+    return _nbOrientations+1;
+  }
+  dir/=norm;
+  double maxw = 0.f; 
+  unsigned winner = _nbOrientations+1;
+  for(unsigned i=0; i<_nbOrientations; ++i){
+    double w = ComputeWeight(dir, i);
+    if(w>maxw){
+      maxw = w;
+      winner = i;
+    }
+  }
+  return winner;
+}
+
+
+unsigned SteerableViewMap::getSVMNumber(unsigned id){
+  map<unsigned int, double* >::iterator o = _mapping.find(id);
+  if(o!=_mapping.end()){
+    double* wvalues=  (*o).second;
+    double maxw = 0.f; 
+    unsigned winner = _nbOrientations+1;
+    for(unsigned i=0; i<_nbOrientations; ++i){
+      double w = wvalues[i];
+      if(w>maxw){
+        maxw = w;
+        winner = i;
+      } 
+    }  
+    return winner;
+  }
+  return _nbOrientations+1;
+}
+
+void SteerableViewMap::buildImagesPyramids(GrayImage **steerableBases, bool copy, unsigned iNbLevels, float iSigma){
+  for(unsigned i=0; i<=_nbOrientations; ++i){
+    ImagePyramid * svm = (_imagesPyramids)[i];
+    if(svm)
+      delete svm;
+    if(copy)
+      svm = new GaussianPyramid(*(steerableBases[i]), iNbLevels, iSigma);
+    else
+      svm = new GaussianPyramid(steerableBases[i], iNbLevels, iSigma);
+    _imagesPyramids[i] = svm;
+  }
+}
+
+float SteerableViewMap::readSteerableViewMapPixel(unsigned iOrientation, int iLevel, int x, int y){
+  ImagePyramid *pyramid = _imagesPyramids[iOrientation];
+  if(pyramid==0){
+    cout << "Warning: this steerable ViewMap level doesn't exist" << endl;
+    return 0;
+  }
+  if((x<0) || (x>=pyramid->width()) || (y<0) || (y>=pyramid->height()))
+    return 0;
+  //float v = pyramid->pixel(x,pyramid->height()-1-y,iLevel)*255.f;
+  float v = pyramid->pixel(x,pyramid->height()-1-y,iLevel)/32.f; // we encode both the directionality and the lines counting on 8 bits 
+                                                                 // (because of frame buffer). Thus, we allow until 8 lines to pass through
+                                                                 // the same pixel, so that we can discretize the Pi/_nbOrientations angle into 
+                                                                 // 32 slices. Therefore, for example, in the vertical direction, a vertical line
+                                                                 // will have the value 32 on each pixel it passes through.
+  return v;
+}
+
+float SteerableViewMap::readCompleteViewMapPixel(int iLevel, int x, int y){
+  return readSteerableViewMapPixel(_nbOrientations,iLevel,x,y);
+}
+
+unsigned int SteerableViewMap::getNumberOfPyramidLevels() const{
+  if(_imagesPyramids[0])
+    return _imagesPyramids[0]->getNumberOfLevels();
+  return 0;
+}
+
+void SteerableViewMap::saveSteerableViewMap() const {
+  for(unsigned i=0; i<=_nbOrientations; ++i){
+    if(_imagesPyramids[i] == 0){
+      cerr << "SteerableViewMap warning: orientation " << i <<" of steerable View Map whas not been computed yet" << endl;
+      continue;
+    }
+    int ow = _imagesPyramids[i]->width(0);
+    int oh = _imagesPyramids[i]->height(0);
+
+    //soc QString base("SteerableViewMap");
+	string base("SteerableViewMap");
+	stringstream filename;
+	
+    for(int j=0; j<_imagesPyramids[i]->getNumberOfLevels(); ++j){ //soc
+      float coeff = 1;//1/255.f; //100*255;//*pow(2,j);
+	  //soc QImage qtmp(ow, oh, QImage::Format_RGB32);
+	  ImBuf *ibuf = IMB_allocImBuf(ow, oh, 32, IB_rect, 0);
+	  int rowbytes = ow*4;
+	  char *pix;
+      
+	for(int y=0;y<oh;++y){ //soc
+		for(int x=0;x<ow;++x){ //soc
+          int c = (int)(coeff*_imagesPyramids[i]->pixel(x,y,j));
+          if(c>255)
+            c=255;
+          //int c = (int)(_imagesPyramids[i]->pixel(x,y,j));
+          
+		//soc qtmp.setPixel(x,y,qRgb(c,c,c));
+		  pix = (char*)ibuf->rect + y*rowbytes + x*4;
+		pix[0] = pix [1] = pix[2] = c;
+        }
+      }
+
+      //soc qtmp.save(base+QString::number(i)+"-"+QString::number(j)+".png", "PNG");
+	filename << base;
+	filename << i << "-" << j << ".png";
+	
+	imb_savepng(ibuf, const_cast<char *>(filename.str().c_str()), 0);
+	
+    }
+    //    QString base("SteerableViewMap");
+    //    for(unsigned j=0; j<_imagesPyramids[i]->getNumberOfLevels(); ++j){
+    //      GrayImage * img = _imagesPyramids[i]->getLevel(j);
+    //      int ow = img->width();
+    //      int oh = img->height();
+    //      float coeff = 1; //100*255;//*pow(2,j);
+    //      QImage qtmp(ow, oh, 32);
+    //      for(unsigned y=0;y<oh;++y){
+    //        for(unsigned x=0;x<ow;++x){
+    //          int c = (int)(coeff*img->pixel(x,y));
+    //          if(c>255)
+    //            c=255;
+    //          //int c = (int)(_imagesPyramids[i]->pixel(x,y,j));
+    //          qtmp.setPixel(x,y,qRgb(c,c,c));
+    //        }
+    //      }
+    //      qtmp.save(base+QString::number(i)+"-"+QString::number(j)+".png", "PNG");
+    //    }
+    //    
+  }
+}
diff --git a/source/blender/freestyle/intern/view_map/SteerableViewMap.h b/source/blender/freestyle/intern/view_map/SteerableViewMap.h
new file mode 100755
index 00000000000..fe7c2493752
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/SteerableViewMap.h
@@ -0,0 +1,153 @@
+//
+//  Filename         : SteerbaleViewMap.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Convenient access to the steerable ViewMap
+//                     to which any element of the ViewMap belongs to.
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+#ifndef  STEERABLEVIEWMAP_H
+# define STEERABLEVIEWMAP_H
+ 
+#include <map>
+#include "../system/FreestyleConfig.h"
+#include "../geometry/Geom.h"
+using namespace Geometry;
+
+using namespace std;
+
+class FEdge;
+class ImagePyramid;
+class GrayImage;
+/*! This class checks for every FEdge in which steerable 
+ *  it belongs and stores the mapping allowing to retrieve 
+ *  this information from the FEdge Id 
+ */
+class LIB_VIEW_MAP_EXPORT SteerableViewMap{
+protected:
+  map<unsigned int, double* > _mapping; // for each vector the list of nbOrientations weigths corresponding to its contributions to the nbOrientations directional maps
+  unsigned _nbOrientations;
+  ImagePyramid **_imagesPyramids; // the pyramids of images storing the different SVM
+
+  // internal
+  double _bound; // cos(Pi/N)
+  vector<Vec2d> _directions;
+
+public:
+  SteerableViewMap(unsigned int nbOrientations = 4);
+  SteerableViewMap(const SteerableViewMap& iBrother);
+  virtual ~SteerableViewMap();
+
+  /*! Resets everything */
+  virtual void Reset();
+
+  /*! Adds a FEdge to steerable VM.
+   *  Returns the nbOrientations weigths corresponding to 
+   *  the FEdge contributions to the nbOrientations directional maps.
+   */
+  double* AddFEdge(FEdge *iFEdge);
+
+  /*! Compute the weight of direction dir for orientation iNOrientation */
+  double ComputeWeight(const Vec2d& dir, unsigned iNOrientation);
+
+  /*! Returns the number of the SVM to which a direction belongs 
+   *  to.
+   *  \param dir
+   *    The direction
+   */
+  unsigned getSVMNumber(const Vec2f& dir);
+
+  /*! Returns the number of the SVM to which a FEdge belongs 
+   *  most.
+   *  \param id
+   *    The First element of the Id struct of the FEdge 
+   *    we're intersted in.
+   */
+  unsigned getSVMNumber(unsigned id);
+
+  /*! Builds _nbOrientations+1 pyramids of images from the _nbOrientations+1 base images 
+   *  of the steerable viewmap.
+   *  \param steerableBases
+   *    The _nbOrientations+1 images constituing the basis for the steerable
+   *    pyramid.
+   *  \param copy
+   *    If false, the data is not duplicated, and Canvas deals
+   *    with the memory management of these _nbOrientations+1 images. If true, data 
+   *    is copied, and it's up to the caller to delete the images.
+   *  \params iNbLevels
+   *    The number of levels desired for each pyramid.
+   *    If iNbLevels == 0, the complete pyramid is built.
+   *  \param iSigma
+   *    The sigma that will be used for the gaussian blur
+   */
+  void buildImagesPyramids(GrayImage **steerableBases, bool copy = false, unsigned iNbLevels=4, float iSigma = 1.f);
+
+  /*! Reads a pixel value in one of the VewMap density steerable pyramids.
+   *  Returns a value between 0 and 1.
+   *  \param iOrientation
+   *    the number telling which orientation we need to check.
+   *    There are _nbOrientations+1 oriented ViewMaps:
+   *    0 -> the ViewMap containing every horizontal lines
+   *    1 -> the ViewMap containing every lines whose orientation is around PI/4
+   *    2 -> the ViewMap containing every vertical lines
+   *    3 -> the ViewMap containing every lines whose orientation is around 3PI/4
+   *    4 -> the complete ViewMap
+   *  \param iLevel
+   *    The level of the pyramid we want to read
+   *  \param x
+   *    The abscissa of the desired pixel specified in level0 coordinate 
+   *    system. The origin is the lower left corner.
+   *  \param y
+   *    The ordinate of the desired pixel specified in level0 coordinate 
+   *    system. The origin is the lower left corner.
+   */
+  float readSteerableViewMapPixel(unsigned iOrientation, int iLevel, int x, int y);
+
+  /*! Reads a pixel in the one of the level of the 
+   *  pyramid containing the images of the complete 
+   *  ViewMap.
+   *  Returns a value between 0 and 1.
+   *  Equivalent to : readSteerableViewMapPixel(nbOrientations, x,y)
+   */
+  float readCompleteViewMapPixel(int iLevel, int x, int y);
+
+  /*! Returns the number of levels in the pyramids */
+  unsigned int getNumberOfPyramidLevels() const;
+  
+  /*! Returns the number of orientations */
+  unsigned int getNumberOfOrientations() const{
+    return _nbOrientations;
+  }
+
+  /*! for debug purposes */
+  void saveSteerableViewMap() const ;
+
+protected:
+  void Clear();
+  void Build();
+
+
+};
+
+#endif // STEERABLEVIEWMAP_H
diff --git a/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
new file mode 100755
index 00000000000..3feeb6664df
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
@@ -0,0 +1,666 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ViewEdgeXBuilder.h"
+#include "../winged_edge/WXEdge.h"
+#include "ViewMap.h"
+#include "SilhouetteGeomEngine.h"
+#include <list>
+
+using namespace std;
+
+void ViewEdgeXBuilder::Init(ViewShape *oVShape){
+  if(0 == oVShape)
+    return;
+
+  // for design conveniance, we store the current SShape.
+  _pCurrentSShape = oVShape->sshape();
+  if(0 == _pCurrentSShape)
+    return;
+
+  _pCurrentVShape = oVShape;
+  
+  // Reset previous data
+  //--------------------
+  if(!_SVertexMap.empty())
+    _SVertexMap.clear();
+}
+
+void ViewEdgeXBuilder::BuildViewEdges( WXShape *iWShape, ViewShape *oVShape, 
+                                      vector<ViewEdge*>& ioVEdges, 
+                                      vector<ViewVertex*>& ioVVertices,
+                                      vector<FEdge*>& ioFEdges,
+                                      vector<SVertex*>& ioSVertices){
+  // Reinit structures
+  Init(oVShape);
+
+  ViewEdge *vedge ;
+  // Let us build the smooth stuff 
+  //----------------------------------------  
+  // We parse all faces to find the ones 
+  // that contain smooth edges
+  vector<WFace*>& wfaces = iWShape->GetFaceList();
+  vector<WFace*>::iterator wf, wfend;
+  WXFace *wxf;
+  for(wf=wfaces.begin(), wfend=wfaces.end();
+  wf!=wfend;
+  wf++){
+    wxf = dynamic_cast<WXFace*>(*wf);
+    if(false == ((wxf))->hasSmoothEdges()) // does it contain at least one smooth edge ?
+      continue;
+    // parse all smooth layers:
+    vector<WXFaceLayer*>& smoothLayers = wxf->getSmoothLayers();
+    for(vector<WXFaceLayer*>::iterator sl = smoothLayers.begin(), slend=smoothLayers.end();
+    sl!=slend;
+    ++sl){
+      if(!(*sl)->hasSmoothEdge())
+        continue;
+      if(stopSmoothViewEdge((*sl))) // has it been parsed already ?
+        continue;
+      // here we know that we're dealing with a face layer that has not been 
+      // processed yet and that contains a smooth edge.
+      vedge = BuildSmoothViewEdge(OWXFaceLayer(*sl, true));
+    }
+  }
+  
+  // Now let's build sharp view edges:
+  //----------------------------------
+  // Reset all userdata for WXEdge structure
+  //----------------------------------------
+  //iWShape->ResetUserData();
+  
+  WXEdge * wxe;
+  vector<WEdge*>& wedges = iWShape->GetEdgeList();
+  // 
+  //------------------------------
+  for(vector<WEdge*>::iterator we=wedges.begin(),weend=wedges.end();
+  we!=weend;
+  we++){
+    wxe = dynamic_cast<WXEdge*>(*we);
+    if(Nature::NO_FEATURE == wxe->nature())
+      continue;
+    
+    if(!stopSharpViewEdge(wxe)){
+      bool b=true;
+      if(wxe->order() == -1)
+        b = false;
+      BuildSharpViewEdge(OWXEdge(wxe,b));
+    }
+  }
+
+  // Reset all userdata for WXEdge structure
+  //----------------------------------------
+  iWShape->ResetUserData();
+ 
+  // Add all these new edges to the scene's feature edges list:
+  //-----------------------------------------------------------
+  vector<FEdge*>& newedges = _pCurrentSShape->GetEdgeList();
+  vector<SVertex*>& newVertices = _pCurrentSShape->GetVertexList();
+  vector<ViewVertex*>& newVVertices = _pCurrentVShape->vertices();
+  vector<ViewEdge*>& newVEdges = _pCurrentVShape->edges();
+
+  // inserts in ioFEdges, at its end, all the edges of newedges
+  ioFEdges.insert(ioFEdges.end(), newedges.begin(), newedges.end());
+  ioSVertices.insert(ioSVertices.end(), newVertices.begin(), newVertices.end());
+  ioVVertices.insert(ioVVertices.end(), newVVertices.begin(), newVVertices.end());
+  ioVEdges.insert(ioVEdges.end(), newVEdges.begin(), newVEdges.end());
+
+}
+
+ViewEdge * ViewEdgeXBuilder::BuildSmoothViewEdge(const OWXFaceLayer& iFaceLayer){
+  // Find first edge:
+  OWXFaceLayer first = iFaceLayer;
+  OWXFaceLayer currentFace = first;
+  
+  // bidirectional chaining.
+  // first direction
+  list<OWXFaceLayer> facesChain;
+  unsigned size  = 0;
+  while(!stopSmoothViewEdge(currentFace.fl)){
+    facesChain.push_back(currentFace);
+    ++size;
+    currentFace.fl->userdata = (void*)1; // processed
+    // Find the next edge!
+    currentFace =  FindNextFaceLayer(currentFace);
+  }
+  OWXFaceLayer end = facesChain.back();
+  // second direction
+  currentFace = FindPreviousFaceLayer(first);
+  while(!stopSmoothViewEdge(currentFace.fl)){
+    facesChain.push_front(currentFace);
+    ++size;
+    currentFace.fl->userdata = (void*)1; // processed
+    // Find the previous edge!
+    currentFace =  FindPreviousFaceLayer(currentFace);
+  }
+  first = facesChain.front();
+  
+  if(iFaceLayer.fl->nature() & Nature::RIDGE){
+    if(size<4){
+      return 0;
+    }
+  }
+  
+  // Start a new chain edges
+  ViewEdge * newVEdge = new ViewEdge;
+  newVEdge->setId(_currentViewId);
+  ++_currentViewId;
+  
+  _pCurrentVShape->AddEdge(newVEdge);
+  
+
+  // build FEdges
+  FEdge * feprevious = 0;
+  FEdge * fefirst = 0;
+  FEdge * fe = 0;
+  for(list<OWXFaceLayer>::iterator fl = facesChain.begin(), flend=facesChain.end();
+  fl!=flend;
+  ++fl){
+    fe = BuildSmoothFEdge(feprevious, (*fl));
+    fe->setViewEdge(newVEdge);
+    if(!fefirst)
+      fefirst = fe;
+    feprevious = fe;
+  }
+  // Store the chain starting edge:
+  _pCurrentSShape->AddChain(fefirst);
+  newVEdge->setNature(iFaceLayer.fl->nature());
+  newVEdge->setFEdgeA(fefirst);
+  newVEdge->setFEdgeB(fe);
+
+  // is it a closed loop ?
+  if((first == end) && (size != 1)){
+    fefirst->setPreviousEdge(fe);
+    fe->setNextEdge(fefirst);
+    newVEdge->setA(0);
+    newVEdge->setB(0);
+  }else{
+    ViewVertex *vva = MakeViewVertex(fefirst->vertexA());
+    ViewVertex *vvb = MakeViewVertex(fe->vertexB());
+        
+    ((NonTVertex*)vva)->AddOutgoingViewEdge(newVEdge);
+    ((NonTVertex*)vvb)->AddIncomingViewEdge(newVEdge);
+
+    newVEdge->setA(vva);
+    newVEdge->setB(vvb);
+  } 
+  
+  return newVEdge;
+}
+
+ViewEdge * ViewEdgeXBuilder::BuildSharpViewEdge(const OWXEdge& iWEdge) {
+  // Start a new sharp chain edges
+  ViewEdge * newVEdge = new ViewEdge;
+  newVEdge->setId(_currentViewId);
+  ++_currentViewId;
+  unsigned size=0;
+  
+  _pCurrentVShape->AddEdge(newVEdge);
+  
+  // Find first edge:
+  OWXEdge firstWEdge = iWEdge;
+  OWXEdge previousWEdge = firstWEdge;
+  OWXEdge currentWEdge = firstWEdge;
+  list<OWXEdge> edgesChain;
+  // bidirectional chaining
+  // first direction:
+  while(!stopSharpViewEdge(currentWEdge.e)){
+    edgesChain.push_back(currentWEdge);
+    ++size;
+    currentWEdge.e->userdata = (void*)1; // processed
+    // Find the next edge!
+    currentWEdge =  FindNextWEdge(currentWEdge);
+  }
+  OWXEdge endWEdge = edgesChain.back();
+  // second direction
+  currentWEdge = FindPreviousWEdge(firstWEdge);
+  while(!stopSharpViewEdge(currentWEdge.e)){
+    edgesChain.push_front(currentWEdge);
+    ++size;
+    currentWEdge.e->userdata = (void*)1; // processed
+    // Find the previous edge!
+    currentWEdge =  FindPreviousWEdge(currentWEdge);
+  }
+  firstWEdge = edgesChain.front();
+
+  // build FEdges
+  FEdge * feprevious = 0;
+  FEdge * fefirst = 0;
+  FEdge * fe = 0;
+  for(list<OWXEdge>::iterator we = edgesChain.begin(), weend=edgesChain.end();
+  we!=weend;
+  ++we){
+    fe = BuildSharpFEdge(feprevious, (*we));
+    fe->setViewEdge(newVEdge);
+    if(!fefirst)
+      fefirst = fe;
+    feprevious = fe;
+  }
+  // Store the chain starting edge:
+  _pCurrentSShape->AddChain(fefirst);
+  newVEdge->setNature(iWEdge.e->nature());
+  newVEdge->setFEdgeA(fefirst);
+  newVEdge->setFEdgeB(fe);
+
+  // is it a closed loop ?
+  if((firstWEdge == endWEdge) && (size!=1)){
+    fefirst->setPreviousEdge(fe);
+    fe->setNextEdge(fefirst);
+    newVEdge->setA(0);
+    newVEdge->setB(0);
+  }else{
+    ViewVertex *vva = MakeViewVertex(fefirst->vertexA());
+    ViewVertex *vvb = MakeViewVertex(fe->vertexB());
+        
+    ((NonTVertex*)vva)->AddOutgoingViewEdge(newVEdge);
+    ((NonTVertex*)vvb)->AddIncomingViewEdge(newVEdge);
+
+    newVEdge->setA(vva);
+    newVEdge->setB(vvb);
+  }
+
+  return newVEdge;
+}
+
+OWXFaceLayer ViewEdgeXBuilder::FindNextFaceLayer(const OWXFaceLayer& iFaceLayer){
+  WXFace *nextFace = 0;
+  WOEdge * woeend;
+  real tend;
+  if(iFaceLayer.order){
+    woeend = iFaceLayer.fl->getSmoothEdge()->woeb();
+    tend = iFaceLayer.fl->getSmoothEdge()->tb();
+  }else{
+    woeend = iFaceLayer.fl->getSmoothEdge()->woea();
+    tend = iFaceLayer.fl->getSmoothEdge()->ta();
+  }
+  // special case of EDGE_VERTEX config:
+  if((tend == 0.0) || (tend == 1.0)){
+    WVertex *nextVertex;
+    if(tend == 0.0)
+      nextVertex = woeend->GetaVertex();
+    else
+      nextVertex = woeend->GetbVertex();
+    if(nextVertex->isBoundary()) // if it's a non-manifold vertex -> ignore
+      return OWXFaceLayer(0,true);
+    bool found = false;
+    WVertex::face_iterator f=nextVertex->faces_begin();
+    WVertex::face_iterator fend=nextVertex->faces_end();
+    while((!found) && (f!=fend)){
+      nextFace = dynamic_cast<WXFace*>(*f);
+      if((0 != nextFace) && (nextFace!=iFaceLayer.fl->getFace())){
+        vector<WXFaceLayer*> sameNatureLayers;
+        nextFace->retrieveSmoothEdgesLayers(iFaceLayer.fl->nature(), sameNatureLayers);
+        if(sameNatureLayers.size() == 1) {// don't know 
+          // maybe should test whether this face has 
+          // also a vertex_edge configuration
+          WXFaceLayer * winner = sameNatureLayers[0];
+          if(woeend == winner->getSmoothEdge()->woea()->twin())
+            return OWXFaceLayer(winner,true);
+          else
+            return OWXFaceLayer(winner,false);
+        }
+      }
+      ++f;
+    }
+  }else{
+    nextFace = dynamic_cast<WXFace*>(iFaceLayer.fl->getFace()->GetBordingFace(woeend));
+    if(0 == nextFace)
+      return OWXFaceLayer(0,true);
+    // if the next face layer has either no smooth edge or 
+    // no smooth edge of same nature, no next face
+    if(!nextFace->hasSmoothEdges())
+      return OWXFaceLayer(0,true);
+    vector<WXFaceLayer*> sameNatureLayers;
+    nextFace->retrieveSmoothEdgesLayers(iFaceLayer.fl->nature(), sameNatureLayers);
+    if((sameNatureLayers.empty()) || (sameNatureLayers.size() != 1)) // don't know how to deal with several edges of same nature on a single face
+      return OWXFaceLayer(0,true);
+    else{
+      WXFaceLayer * winner = sameNatureLayers[0];
+      if(woeend == winner->getSmoothEdge()->woea()->twin())
+        return OWXFaceLayer(winner,true);
+      else
+        return OWXFaceLayer(winner,false);
+    } 
+  }
+  return OWXFaceLayer(0,true);
+}
+
+OWXFaceLayer ViewEdgeXBuilder::FindPreviousFaceLayer(const OWXFaceLayer& iFaceLayer) {
+  WXFace *previousFace = 0;
+  WOEdge * woebegin;
+  real tend;
+  if(iFaceLayer.order){
+    woebegin = iFaceLayer.fl->getSmoothEdge()->woea();
+    tend = iFaceLayer.fl->getSmoothEdge()->ta();
+  }else{
+    woebegin = iFaceLayer.fl->getSmoothEdge()->woeb();
+    tend = iFaceLayer.fl->getSmoothEdge()->tb();
+  }
+
+  // special case of EDGE_VERTEX config:
+  if((tend == 0.0) || (tend == 1.0)){
+    WVertex *previousVertex;
+    if(tend == 0.0)
+      previousVertex = woebegin->GetaVertex();
+    else
+      previousVertex = woebegin->GetbVertex();
+    if(previousVertex->isBoundary()) // if it's a non-manifold vertex -> ignore
+      return OWXFaceLayer(0,true);
+    bool found = false;
+    WVertex::face_iterator f=previousVertex->faces_begin();
+    WVertex::face_iterator fend=previousVertex->faces_end();
+    while((!found) && (f!=fend)){
+      previousFace = dynamic_cast<WXFace*>(*f);
+      if((0 != previousFace) && (previousFace!=iFaceLayer.fl->getFace())){
+        vector<WXFaceLayer*> sameNatureLayers;
+        previousFace->retrieveSmoothEdgesLayers(iFaceLayer.fl->nature(), sameNatureLayers);
+        if(sameNatureLayers.size() == 1) {// don't know 
+          // maybe should test whether this face has 
+          // also a vertex_edge configuration
+          WXFaceLayer * winner = sameNatureLayers[0];
+          if(woebegin == winner->getSmoothEdge()->woeb()->twin())
+            return OWXFaceLayer(winner,true);
+          else
+            return OWXFaceLayer(winner,false);
+        }
+      }
+      ++f;
+    }
+  }else{
+    previousFace = dynamic_cast<WXFace*>(iFaceLayer.fl->getFace()->GetBordingFace(woebegin));
+    if(0 == previousFace)
+      return OWXFaceLayer(0,true);
+    
+    // if the next face layer has either no smooth edge or 
+    // no smooth edge of same nature, no next face
+    if(!previousFace->hasSmoothEdges())
+      return OWXFaceLayer(0,true);
+    vector<WXFaceLayer*> sameNatureLayers;
+    previousFace->retrieveSmoothEdgesLayers(iFaceLayer.fl->nature(), sameNatureLayers);
+    if((sameNatureLayers.empty()) || (sameNatureLayers.size() != 1)) // don't know how to deal with several edges of same nature on a single face
+      return OWXFaceLayer(0,true);
+    else{
+      WXFaceLayer * winner = sameNatureLayers[0];
+      if(woebegin == winner->getSmoothEdge()->woeb()->twin())
+        return OWXFaceLayer(winner,true);
+      else
+        return OWXFaceLayer(winner,false);
+    }
+  }
+  return OWXFaceLayer(0,true);
+}
+
+FEdge * ViewEdgeXBuilder::BuildSmoothFEdge(FEdge *feprevious, const OWXFaceLayer& ifl){
+  SVertex *va, *vb;
+  FEdgeSmooth *fe;
+  // retrieve exact silhouette data
+  WXSmoothEdge *se = ifl.fl->getSmoothEdge();
+
+  Vec3r normal;
+  // Make the 2 Svertices
+  if(feprevious == 0){ // that means that we don't have any vertex already built for that face
+    real ta = se->ta();
+    Vec3r A1(se->woea()->GetaVertex()->GetVertex());
+    Vec3r A2(se->woea()->GetbVertex()->GetVertex());
+    Vec3r A(A1+ta*(A2-A1));
+    
+    va = MakeSVertex(A);
+    // Set normal:
+    Vec3r NA1(ifl.fl->getFace()->GetVertexNormal(se->woea()->GetaVertex()));
+    Vec3r NA2(ifl.fl->getFace()->GetVertexNormal(se->woea()->GetbVertex()));
+    Vec3r na((1 - ta) * NA1 + ta * NA2);
+    na.normalize();
+    va->AddNormal(na);
+    normal = na;
+
+    // Set CurvatureInfo
+    CurvatureInfo* curvature_info_a = new CurvatureInfo(*(dynamic_cast<WXVertex*>(se->woea()->GetaVertex())->curvatures()),
+							*(dynamic_cast<WXVertex*>(se->woea()->GetbVertex())->curvatures()),
+							ta);
+    va->setCurvatureInfo(curvature_info_a);
+  }
+  else
+    va = feprevious->vertexB();
+
+  real tb = se->tb();
+  Vec3r B1(se->woeb()->GetaVertex()->GetVertex());
+  Vec3r B2(se->woeb()->GetbVertex()->GetVertex());
+  Vec3r B(B1+tb*(B2-B1));
+
+  vb = MakeSVertex(B);
+  // Set normal:
+  Vec3r NB1(ifl.fl->getFace()->GetVertexNormal(se->woeb()->GetaVertex()));
+  Vec3r NB2(ifl.fl->getFace()->GetVertexNormal(se->woeb()->GetbVertex()));
+  Vec3r nb((1 - tb) * NB1 + tb * NB2);
+  nb.normalize();
+  normal += nb;
+  vb->AddNormal(nb);
+
+  // Set CurvatureInfo
+  CurvatureInfo* curvature_info_b = new CurvatureInfo(*(dynamic_cast<WXVertex*>(se->woeb()->GetaVertex())->curvatures()),
+						      *(dynamic_cast<WXVertex*>(se->woeb()->GetbVertex())->curvatures()),
+						      tb);
+  vb->setCurvatureInfo(curvature_info_b);
+
+  // if the order is false we must swap va and vb
+  if(!ifl.order){
+    SVertex *tmp = va;
+    va = vb;
+    vb = tmp;
+  }
+  
+  // Creates the corresponding feature edge
+  fe = new FEdgeSmooth(va, vb);
+  fe->setNature(ifl.fl->nature());
+  fe->setId(_currentFId);
+  fe->setMaterialIndex(ifl.fl->getFace()->materialIndex());
+  fe->setFace(ifl.fl->getFace());
+  fe->setNormal(normal);
+  fe->setPreviousEdge(feprevious);
+  if(feprevious)
+    feprevious->setNextEdge(fe);
+  _pCurrentSShape->AddEdge(fe);
+  va->AddFEdge(fe);
+  vb->AddFEdge(fe);
+  
+  ++_currentFId;
+  ifl.fl->userdata = fe;
+  return fe;
+}
+
+bool ViewEdgeXBuilder::stopSmoothViewEdge(WXFaceLayer *iFaceLayer){
+  if(0 == iFaceLayer)
+    return true;
+  if(iFaceLayer->userdata == 0)
+    return false;
+  return true;
+}
+
+OWXEdge ViewEdgeXBuilder::FindNextWEdge(const OWXEdge& iEdge){
+  if(Nature::NO_FEATURE == iEdge.e->nature())
+    return OWXEdge(0, true);
+
+  WVertex *v;
+  if(true == iEdge.order)
+    v = iEdge.e->GetbVertex();
+  else
+    v = iEdge.e->GetaVertex();
+
+  if(((WXVertex*)v)->isFeature())
+    return 0;
+
+  
+  vector<WEdge*>& vEdges = (v)->GetEdges();
+  for(vector<WEdge*>::iterator ve=vEdges.begin(),veend=vEdges.end();
+  ve!=veend;
+  ve++){ 
+    WXEdge *wxe = dynamic_cast<WXEdge*>(*ve);
+    if(wxe == iEdge.e)
+      continue; // same edge as the one processed
+
+    if(wxe->nature() != iEdge.e->nature())
+      continue;
+      
+    if(wxe->GetaVertex() == v){
+     // That means that the face necesarily lies on the edge left.
+     // So the vertex order is OK.
+      return OWXEdge(wxe, true);
+    }else{
+      // That means that the face necesarily lies on the edge left.
+      // So the vertex order is OK.
+      return OWXEdge(wxe, false);
+    }  
+  }   
+  // we did not find:
+  return OWXEdge(0, true);
+}
+
+OWXEdge ViewEdgeXBuilder::FindPreviousWEdge(const OWXEdge& iEdge){
+  if(Nature::NO_FEATURE == iEdge.e->nature())
+    return OWXEdge(0, true);
+
+  WVertex *v;
+  if(true == iEdge.order)
+    v = iEdge.e->GetaVertex();
+  else
+    v = iEdge.e->GetbVertex();
+
+  if(((WXVertex*)v)->isFeature())
+    return 0;
+
+  
+  vector<WEdge*>& vEdges = (v)->GetEdges();
+  for(vector<WEdge*>::iterator ve=vEdges.begin(),veend=vEdges.end();
+  ve!=veend;
+  ve++){ 
+    WXEdge *wxe = dynamic_cast<WXEdge*>(*ve);
+    if(wxe == iEdge.e)
+      continue; // same edge as the one processed
+
+    if(wxe->nature() != iEdge.e->nature())
+      continue;
+      
+    if(wxe->GetbVertex() == v){
+      return OWXEdge(wxe, true);
+    }else{
+      return OWXEdge(wxe, false);
+    }  
+  }   
+  // we did not find:
+  return OWXEdge(0, true);
+}
+
+FEdge * ViewEdgeXBuilder::BuildSharpFEdge(FEdge *feprevious, const OWXEdge& iwe){
+  SVertex *va, *vb;
+  FEdgeSharp *fe;
+  WXVertex *wxVA, *wxVB;
+  if(iwe.order){
+    wxVA = (WXVertex*)iwe.e->GetaVertex();
+    wxVB = (WXVertex*)iwe.e->GetbVertex();
+  }else{
+    wxVA = (WXVertex*)iwe.e->GetbVertex();
+    wxVB = (WXVertex*)iwe.e->GetaVertex();
+  }
+  // Make the 2 SVertex
+  va = MakeSVertex(wxVA->GetVertex());
+  vb = MakeSVertex(wxVB->GetVertex());
+
+  // get the faces normals and the material indices
+  Vec3r normalA, normalB;
+  unsigned matA(0), matB(0);
+  if(iwe.order){
+    normalB = (iwe.e->GetbFace()->GetNormal());
+    matB    = (iwe.e->GetbFace()->materialIndex());
+    if(!(iwe.e->nature() & Nature::BORDER)) {  
+      normalA = (iwe.e->GetaFace()->GetNormal());
+      matA    = (iwe.e->GetaFace()->materialIndex());
+    }
+  }else{
+    normalA = (iwe.e->GetbFace()->GetNormal());
+    matA    = (iwe.e->GetbFace()->materialIndex());
+    if(!(iwe.e->nature() & Nature::BORDER)) { 
+      normalB = (iwe.e->GetaFace()->GetNormal());
+      matB    = (iwe.e->GetaFace()->materialIndex());
+    }
+  }
+  // Creates the corresponding feature edge
+  // Creates the corresponding feature edge
+  fe = new FEdgeSharp(va, vb);
+  fe->setNature(iwe.e->nature());
+  fe->setId(_currentFId);
+  fe->setaMaterialIndex(matA);
+  fe->setbMaterialIndex(matB);
+  fe->setNormalA(normalA);
+  fe->setNormalB(normalB);
+  fe->setPreviousEdge(feprevious);
+  if(feprevious)
+    feprevious->setNextEdge(fe);
+  _pCurrentSShape->AddEdge(fe);
+  va->AddFEdge(fe);
+  vb->AddFEdge(fe);
+  //Add normals:
+  va->AddNormal(normalA);
+  va->AddNormal(normalB);
+  vb->AddNormal(normalA);
+  vb->AddNormal(normalB);
+  
+  ++_currentFId;
+  iwe.e->userdata = fe;
+  return fe;
+}
+
+bool ViewEdgeXBuilder::stopSharpViewEdge(WXEdge *iEdge){
+  if(0 == iEdge)
+    return true;
+  if(iEdge->userdata == 0)
+    return false;
+  return true;
+}
+
+SVertex * ViewEdgeXBuilder::MakeSVertex(Vec3r& iPoint){
+  SVertex *va;
+  // Check whether the vertices are already in the table:
+  // fisrt vertex
+  // -------------
+  SVertexMap::const_iterator found = _SVertexMap.find(iPoint);
+  if (found != _SVertexMap.end()) {
+    va = (*found).second;
+  }else{
+    va = new SVertex(iPoint, _currentSVertexId);
+    SilhouetteGeomEngine::ProjectSilhouette(va);
+    ++_currentSVertexId;
+    // Add the svertex to the SShape svertex list:
+    _pCurrentSShape->AddNewVertex(va);
+    // Add the svertex in the table using its id:
+    _SVertexMap[iPoint] = va; 
+  }
+  return va;
+}
+
+ViewVertex * ViewEdgeXBuilder::MakeViewVertex(SVertex *iSVertex){
+  ViewVertex *vva = iSVertex->viewvertex();  
+  if(vva != 0)
+    return vva;
+  vva = new NonTVertex(iSVertex);
+  // Add the view vertex to the ViewShape svertex list:
+  _pCurrentVShape->AddVertex(vva);    
+  return vva;
+}
+
diff --git a/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
new file mode 100755
index 00000000000..28a5d7d9dd4
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
@@ -0,0 +1,215 @@
+//
+//  Filename         : ViewEdgeXBuilder.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to build view edges and the underlying chains
+//                     of feature edges...
+//  Date of creation : 27/10/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWEDGEXBUILDER_H
+# define VIEWEDGEXBUILDER_H
+
+# include <map>
+# include <utility>
+# include <vector>
+
+// soc
+// # if defined(__GNUC__) && (__GNUC__ >= 3)
+// //hash_map is not part of the C++ standard anymore; hash_map.h has been kept though for backward compatibility
+// #  include <hash_map.h>
+// # else
+// #  include <hash_map>
+// # endif
+
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+# include "Interface1D.h"
+
+using namespace Geometry;
+using namespace std;
+
+class SVertex;
+/*! Defines a hash table used for searching the SVertex */
+struct SVertexHasher {
+#define _MUL 950706376UL
+#define _MOD 2147483647UL
+  inline size_t operator() (const Vec3r& p) const {
+    size_t res = ((unsigned long) (p[0] * _MUL)) % _MOD;
+    res = ((res + (unsigned long) (p[1]) * _MUL)) % _MOD;
+    return ((res +(unsigned long) (p[2]) * _MUL)) % _MOD;
+  }
+};
+
+// Key_compare predicate for hash_map. In particular, return false if equal.
+struct epsilonEquals{
+  bool operator()(const Vec3r& v1, const Vec3r& v2) const{
+    real norm = (v1-v2).norm();
+    return (norm<1e-06);
+  }
+};
+
+
+// typedef hash_map<Vec3r, SVertex*, SVertexHasher, epsilonEquals> SVertexMap;
+typedef map<Vec3r , SVertex*> SVertexMap;
+
+class WXFaceLayer;
+/*! class to describe an oriented smooth edge */
+class OWXFaceLayer{
+public:
+  WXFaceLayer * fl;
+  bool order;
+
+  OWXFaceLayer() {fl=0;order=true;}
+  OWXFaceLayer(WXFaceLayer *ifl, bool iOrder=true){fl = ifl;order=iOrder;}
+  OWXFaceLayer& operator=(const OWXFaceLayer& iBrother){
+    fl = iBrother.fl;
+    order = iBrother.order;
+    return *this;
+  }
+  bool operator==(const OWXFaceLayer& b){
+    return ((fl == b.fl) && (order == b.order));
+  }
+  bool operator!=(const OWXFaceLayer& b){
+    return !(*this==b);
+  }
+};
+
+class WXEdge;
+/*! class to describe an oriented sharp edge */
+class OWXEdge{
+public:
+  WXEdge * e;
+  bool order;
+
+  OWXEdge() {e=0;order=true;}
+  OWXEdge(WXEdge *ie, bool iOrder=true){e = ie;order=iOrder;}
+  OWXEdge& operator=(const OWXEdge& iBrother){
+    e = iBrother.e;
+    order = iBrother.order;
+    return *this;
+  }
+  bool operator==(const OWXEdge& b){
+    return ((e == b.e) && (order == b.order));
+  }
+  bool operator!=(const OWXEdge& b){
+    return !(*this==b);
+  }
+};
+
+class WOEdge;
+class WXEdge;
+class WXShape;
+class SVertex;
+class FEdge;
+class ViewVertex;
+class ViewEdge;
+class ViewShape;
+class LIB_VIEW_MAP_EXPORT ViewEdgeXBuilder
+{
+protected:
+  int _currentViewId; // Id for view edges
+  int _currentFId;    // Id for FEdges
+  int _currentSVertexId;    // Id for SVertex
+public:
+  
+  inline ViewEdgeXBuilder() 
+  {_currentViewId = 1;_currentFId=0;_currentSVertexId=0;}
+  virtual ~ViewEdgeXBuilder(){}
+
+  /*! Builds a view shape from a WXShape in which the feature edges 
+   *  are flagged
+   *  Builds chains of feature edges (so ViewEdges) from a WXShape
+   *    iWShape
+   *      The Winged Edge structure in which all silhouette edges
+   *      and vertices are flagged.
+   *    oViewShape
+   *      The Silhouette Shape in which the chains must be added.
+   *    ioVEdges
+   *      The list of new ViewEdges.
+   *    ioVVertices
+   *      THe new ViewVertices
+   *    ioFEdges
+   *      A list in which all new FEdges are added
+   *    ioSVertices
+   *      A list of SVertex where all created SVertex are added.
+   */
+  virtual void BuildViewEdges(WXShape *iWShape, ViewShape *oVShape, 
+                      std::vector<ViewEdge*>& ioVEdges, 
+                      std::vector<ViewVertex*>& ioVVertices,
+                      std::vector<FEdge*>& ioFEdges,
+                      std::vector<SVertex*>& ioSVertices) ;
+
+  /*! Builds a smooth view edge, starting the face iFace.*/
+  ViewEdge * BuildSmoothViewEdge(const OWXFaceLayer& iFaceLayer);
+
+  /*! Makes a sharp viewedge 
+   */
+  ViewEdge * BuildSharpViewEdge(const OWXEdge& iWEdge) ;
+
+
+public:
+  /*! accessors */
+  inline int currentViewId() const { return _currentViewId; }
+  inline int currentFId() const { return _currentFId; }
+  inline int currentSVertexId() const { return _currentSVertexId; }
+  /*! modifiers */
+  inline void setCurrentViewId(int id) { _currentViewId = id; }
+  inline void setCurrentFId(int id) { _currentFId = id; }
+  inline void setCurrentSVertexId(int id) { _currentSVertexId = id; }
+
+protected:
+  /*! Init the view edges building */
+  virtual void Init(ViewShape *oVShape) ;
+
+  // SMOOTH //
+  /*! checks whether a face has already been processed or not */
+  bool stopSmoothViewEdge(WXFaceLayer *iFaceLayer);
+  OWXFaceLayer FindNextFaceLayer(const OWXFaceLayer& iFaceLayer);
+  OWXFaceLayer FindPreviousFaceLayer(const OWXFaceLayer& iFaceLayer);
+  FEdge * BuildSmoothFEdge(FEdge *feprevious, const OWXFaceLayer& ifl);
+
+  // SHARP //
+  /*! checks whether a WEdge has already been processed or not */
+  bool stopSharpViewEdge(WXEdge *iFace);
+  OWXEdge FindNextWEdge(const OWXEdge& iEdge);
+  OWXEdge FindPreviousWEdge(const OWXEdge& iEdge);
+  FEdge * BuildSharpFEdge(FEdge *feprevious, const OWXEdge& iwe);
+
+  // GENERAL //
+  /*! Instanciate a SVertex if it hasn't been already created */
+  SVertex * MakeSVertex(Vec3r& iPoint);
+  /*! instanciate a ViewVertex from a SVertex, if it doesn't exist yet */
+  ViewVertex * MakeViewVertex(SVertex *iSVertex);
+
+  //oldtmp values
+  //  IdHashTable _hashtable;
+  //  VVIdHashTable _multivertexHashTable;
+  SVertexMap _SVertexMap;
+  SShape *_pCurrentSShape;
+  ViewShape * _pCurrentVShape;
+};
+
+#endif
+
diff --git a/source/blender/freestyle/intern/view_map/ViewMap.cpp b/source/blender/freestyle/intern/view_map/ViewMap.cpp
new file mode 100755
index 00000000000..e0ae2ca373e
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMap.cpp
@@ -0,0 +1,703 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ViewMap.h"
+#include "../geometry/GeomUtils.h"
+#include <float.h>
+#include "ViewMapIterators.h"
+#include "ViewMapAdvancedIterators.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewMap            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+ViewMap * ViewMap::_pInstance = 0;
+
+ViewMap::~ViewMap()  
+{
+    // The view vertices must be deleted here as some of them
+    // are shared between two shapes:
+    for(vector<ViewVertex*>::iterator vv=_VVertices.begin(), vvend=_VVertices.end();
+    vv!=vvend;
+    vv++)
+    {
+      delete (*vv);
+    }
+    _VVertices.clear();
+
+    for(vector<ViewShape*>::iterator vs=_VShapes.begin(),vsend=_VShapes.end();
+    vs!=vsend;
+    vs++)
+    {
+      delete (*vs);
+    }
+    _VShapes.clear();
+
+    _FEdges.clear();
+    _SVertices.clear();
+    _VEdges.clear();
+}
+
+ViewShape * ViewMap::viewShape(unsigned id) 
+{
+  int index = _shapeIdToIndex[id];
+  return _VShapes[ index ];
+}
+void  ViewMap::AddViewShape(ViewShape *iVShape) {
+    _shapeIdToIndex[iVShape->getId().getFirst()] = _VShapes.size(); 
+    _VShapes.push_back(iVShape);
+}
+const FEdge * ViewMap::GetClosestFEdge(real x, real y) const
+{
+  // find the closest of this candidates:
+  real minDist = DBL_MAX;
+  FEdge * winner = 0;
+  for(fedges_container::const_iterator fe=_FEdges.begin(),feend=_FEdges.end();
+  fe!=feend;
+  fe++)
+  {
+    Vec2d A((*fe)->vertexA()->point2D()[0], (*fe)->vertexA()->point2D()[1]);
+    Vec2d B((*fe)->vertexB()->point2D()[0], (*fe)->vertexB()->point2D()[1]);
+    real dist = GeomUtils::distPointSegment<Vec2r>(Vec2r(x,y),A, B);
+    if(dist < minDist)
+    {
+      minDist = dist;
+      winner = (*fe);
+    }
+    
+  }
+  if(winner==0)
+    return 0;
+  
+  return winner;
+}
+
+const ViewEdge * ViewMap::GetClosestViewEdge(real x, real y) const
+{
+  // find the closest of this candidates:
+  real minDist = DBL_MAX;
+  FEdge * winner = 0;
+  for(fedges_container::const_iterator fe=_FEdges.begin(),feend=_FEdges.end();
+  fe!=feend;
+  fe++)
+  {
+    Vec2d A((*fe)->vertexA()->point2D()[0], (*fe)->vertexA()->point2D()[1]);
+    Vec2d B((*fe)->vertexB()->point2D()[0], (*fe)->vertexB()->point2D()[1]);
+    real dist = GeomUtils::distPointSegment<Vec2r>(Vec2r(x,y),A, B);
+    if(dist < minDist)
+    {
+      minDist = dist;
+      winner = (*fe);
+    }
+    
+  }
+  if(winner==0)
+    return 0;
+  
+  return winner->viewedge();
+}
+
+
+TVertex* ViewMap::CreateTVertex(const Vec3r& iA3D, const Vec3r& iA2D, FEdge *iFEdgeA,
+                                const Vec3r& iB3D, const Vec3r& iB2D, FEdge *iFEdgeB,
+                                const Id& id)
+{
+  ViewShape *vshapeA = iFEdgeA->viewedge()->viewShape();
+  SShape *shapeA = iFEdgeA->shape();
+  ViewShape *vshapeB = iFEdgeB->viewedge()->viewShape();
+  SShape *shapeB = iFEdgeB->shape();
+  
+  SVertex * Ia = shapeA->CreateSVertex(iA3D, iA2D, iFEdgeA->vertexA()->getId());
+  SVertex * Ib = shapeB->CreateSVertex(iB3D, iB2D, iFEdgeB->vertexA()->getId());
+  
+    // depending on which of these 2 svertices is the nearest from the 
+    // viewpoint, we're going to build the TVertex by giving them in 
+    // an order or another (the first one must be the nearest)
+    real dista = Ia->point2D()[2];
+    real distb = Ib->point2D()[2];
+
+    TVertex * tvertex;
+    if(dista < distb)
+      tvertex = new TVertex(Ia, Ib);
+    else
+      tvertex = new TVertex(Ib,Ia);
+
+    tvertex->setId(id);
+    
+    // add these vertices to the view map
+    AddViewVertex(tvertex);
+    AddSVertex(Ia);
+    AddSVertex(Ib);
+
+    // and this T Vertex to the view shapes:
+    vshapeA->AddVertex(tvertex);
+    vshapeB->AddVertex(tvertex);
+
+    return tvertex;
+}
+
+ViewVertex * ViewMap::InsertViewVertex(SVertex *iVertex, 
+                                       vector<ViewEdge*>& newViewEdges){
+  NonTVertex *vva = dynamic_cast<NonTVertex*>(iVertex->viewvertex());  
+  if(vva != 0)
+    return vva;
+  // beacuse it is not already a ViewVertex, this SVertex must have only 
+  // 2 FEdges. The incoming one still belongs to ioEdge, the outgoing one 
+  // now belongs to newVEdge
+  const vector<FEdge*>& fedges = iVertex->fedges();
+  if(fedges.size()!=2){
+    cerr << "ViewMap warning: Can't split the ViewEdge" << endl;
+    return 0;
+  }
+  FEdge * fend(0), * fbegin(0);
+  for(vector<FEdge*>::const_iterator fe=fedges.begin(), feend=fedges.end();
+  fe!=feend;
+  ++fe){
+    if((*fe)->vertexB() == iVertex){
+      fend   = (*fe);
+    }
+    if((*fe)->vertexA() == iVertex){
+      fbegin = (*fe);
+    }
+    if((fbegin!=0) && (fend!=0))
+      break;
+  }
+  ViewEdge *ioEdge = fbegin->viewedge();
+  ViewShape * vshape = ioEdge->viewShape();
+  vva = new NonTVertex(iVertex);
+  // if the ViewEdge is a closed loop, we don't create
+  // a new VEdge
+  if(ioEdge->A() == 0){
+    // closed loop
+    ioEdge->setA(vva);
+    ioEdge->setB(vva);
+    // update sshape
+    vshape->sshape()->RemoveEdgeFromChain(ioEdge->fedgeA());
+    vshape->sshape()->RemoveEdgeFromChain(ioEdge->fedgeB());
+
+    ioEdge->setFEdgeA(fbegin);
+    ioEdge->setFEdgeB(fend);
+
+    // Update FEdges
+    fend->setNextEdge(0);
+    fbegin->setPreviousEdge(0);
+    
+    // update new View Vertex:
+    vva->AddOutgoingViewEdge(ioEdge);
+    vva->AddIncomingViewEdge(ioEdge);
+
+    vshape->sshape()->AddChain(ioEdge->fedgeA());
+    vshape->sshape()->AddChain(ioEdge->fedgeB());
+  }else{
+    // Create new ViewEdge
+    ViewEdge * newVEdge = new ViewEdge(vva, ioEdge->B(), fbegin, ioEdge->fedgeB(), vshape);
+    newVEdge->setId(Id(ioEdge->getId().getFirst(), ioEdge->getId().getSecond()+1));
+    newVEdge->setNature(ioEdge->getNature());
+    //newVEdge->UpdateFEdges(); // done in the ViewEdge constructor
+    // Update old ViewEdge
+    ioEdge->setB(vva);
+    ioEdge->setFEdgeB(fend);
+
+    // Update FEdges
+    fend->setNextEdge(0);
+    fbegin->setPreviousEdge(0);
+
+    // update new View Vertex:
+    vva->AddOutgoingViewEdge(newVEdge);
+    vva->AddIncomingViewEdge(ioEdge);
+    // update ViewShape
+    //vshape->AddEdge(newVEdge);
+    // update SShape
+    vshape->sshape()->AddChain(fbegin);
+    // update ViewMap
+    //_VEdges.push_back(newVEdge);
+    newViewEdges.push_back(newVEdge);
+  }
+  
+  // update ViewShape
+  vshape->AddVertex(vva);
+  
+  // update ViewMap
+  _VVertices.push_back(vva);
+  
+  return vva;
+}
+
+//FEdge * ViewMap::Connect(FEdge *ioEdge, SVertex *ioVertex, vector<ViewEdge*>& oNewVEdges){
+//  SShape * sshape = ioEdge->shape();
+//  FEdge *newFEdge = sshape->SplitEdgeIn2(ioEdge, ioVertex);
+//  AddFEdge(newFEdge);
+//  InsertViewVertex(ioVertex, oNewVEdges);
+//  return  newFEdge;
+//}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             TVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+// is dve1 before dve2 ? (does it have a smaller angle ?)
+bool ViewEdgeComp(ViewVertex::directedViewEdge& dve1, ViewVertex::directedViewEdge& dve2){
+  FEdge *fe1;
+  if(dve1.second)
+    fe1 = dve1.first->fedgeB();
+  else
+    fe1 = dve1.first->fedgeA();
+  FEdge *fe2;
+  if(dve2.second)
+    fe2 = dve2.first->fedgeB();
+  else
+    fe2 = dve2.first->fedgeA();
+
+  Vec3r V1 = fe1->orientation2d();
+  Vec2r v1(V1.x(), V1.y());v1.normalize();
+  Vec3r V2 = fe2->orientation2d();
+  Vec2r v2(V2.x(), V2.y());v2.normalize();
+  if(v1.y() > 0){
+    if(v2.y() < 0)
+      return true;
+    else 
+      return (v1.x() > v2.x());
+  }else{
+    if(v2.y() > 0)
+      return false;
+    else 
+      return (v1.x() < v2.x());
+  }
+  return false;
+}
+void TVertex::setFrontEdgeA(ViewEdge *iFrontEdgeA, bool incoming) {
+  if (!iFrontEdgeA) {
+    cerr << "Warning: null pointer passed as argument of TVertex::setFrontEdgeA()" << endl;
+    return;
+  }
+  _FrontEdgeA = directedViewEdge(iFrontEdgeA, incoming);
+  if(!_sortedEdges.empty()){
+    edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(**dve, _FrontEdgeA)){
+      ++dve;
+    }
+    _sortedEdges.insert( dve, &_FrontEdgeA);
+  }
+  else
+    _sortedEdges.push_back(&_FrontEdgeA);
+}
+void TVertex::setFrontEdgeB(ViewEdge *iFrontEdgeB, bool incoming) {
+  if (!iFrontEdgeB) {
+    cerr << "Warning: null pointer passed as argument of TVertex::setFrontEdgeB()" << endl;
+    return;
+  }
+  _FrontEdgeB = directedViewEdge(iFrontEdgeB, incoming);
+  if(!_sortedEdges.empty()){
+    edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(**dve, _FrontEdgeB)){
+      ++dve;
+    }
+    _sortedEdges.insert(dve, &_FrontEdgeB);
+  }
+  else
+    _sortedEdges.push_back(&_FrontEdgeB);
+}
+void TVertex::setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming) {
+  if (!iBackEdgeA) {
+    cerr << "Warning: null pointer passed as argument of TVertex::setBackEdgeA()" << endl;
+    return;
+  }
+  _BackEdgeA = directedViewEdge(iBackEdgeA, incoming);
+  if(!_sortedEdges.empty()){
+    edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(**dve, _BackEdgeA)){
+      ++dve;
+    }
+    _sortedEdges.insert(dve, &_BackEdgeA);
+  }
+  else
+    _sortedEdges.push_back(&_BackEdgeA);
+}
+void TVertex::setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming) {
+  if (!iBackEdgeB) {
+    cerr << "Warning: null pointer passed as argument of TVertex::setBackEdgeB()" << endl;
+    return;
+  }
+  _BackEdgeB = directedViewEdge(iBackEdgeB, incoming);
+  if(!_sortedEdges.empty()){
+    edge_pointers_container::iterator dve = _sortedEdges.begin(), dveend = _sortedEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(**dve, _BackEdgeB)){
+      ++dve;
+    }
+    _sortedEdges.insert(dve, &_BackEdgeB);
+  }
+  else
+    _sortedEdges.push_back(&_BackEdgeB);
+}
+void TVertex::Replace(ViewEdge *iOld, ViewEdge *iNew)
+{
+    // theoritically, we only replace edges for which this 
+    // view vertex is the B vertex
+    if((iOld == _FrontEdgeA.first) && (_FrontEdgeA.first->B() == this))
+    {
+      _FrontEdgeA.first = iNew;
+      return; 
+    }
+    if((iOld == _FrontEdgeB.first) && (_FrontEdgeB.first->B() == this))
+    {
+      _FrontEdgeB.first = iNew;
+      return;
+    }
+    if((iOld == _BackEdgeA.first) && (_BackEdgeA.first->B() == this))
+    {
+      _BackEdgeA.first = iNew;
+      return;
+    }
+    if((iOld == _BackEdgeB.first) && (_BackEdgeB.first->B() == this))
+    {
+      _BackEdgeB.first = iNew;
+      return;
+    }
+}
+
+/*! iterators access */
+ViewVertex::edge_iterator TVertex::edges_begin()
+{
+    //return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, _FrontEdgeA);
+  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+}
+ViewVertex::const_edge_iterator TVertex::edges_begin() const
+{
+    //return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, _FrontEdgeA);
+  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+}
+ViewVertex::edge_iterator TVertex::edges_end()
+{ 
+    //return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, directedViewEdge(0,true));
+  return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
+}
+ViewVertex::const_edge_iterator TVertex::edges_end() const
+{ 
+    //return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, directedViewEdge(0, true));
+  return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
+}
+ViewVertex::edge_iterator TVertex::edges_iterator(ViewEdge *iEdge)
+{ 
+  for(edge_pointers_container::iterator it=_sortedEdges.begin(), itend=_sortedEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((*it)->first == iEdge)
+        return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), it);
+    }
+    return edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+
+    //  directedViewEdge dEdge;
+    //  if(_FrontEdgeA.first == iEdge)
+    //    dEdge = _FrontEdgeA;
+    //  else if(_FrontEdgeB.first == iEdge)
+    //    dEdge = _FrontEdgeB;
+    //  else if(_BackEdgeA.first == iEdge)
+    //    dEdge = _BackEdgeA;
+    //  else if(_BackEdgeB.first == iEdge)
+    //    dEdge = _BackEdgeB;
+    //  return edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, dEdge);
+}
+ViewVertex::const_edge_iterator TVertex::edges_iterator(ViewEdge *iEdge) const
+{ 
+  for(edge_pointers_container::const_iterator it=_sortedEdges.begin(), itend=_sortedEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((*it)->first == iEdge)
+        return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), it);
+    }
+    return const_edge_iterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+
+    //  directedViewEdge dEdge;
+    //  if(_FrontEdgeA.first == iEdge)
+    //    dEdge = _FrontEdgeA;
+    //  else if(_FrontEdgeB.first == iEdge)
+    //    dEdge = _FrontEdgeB;
+    //  else if(_BackEdgeA.first == iEdge)
+    //    dEdge = _BackEdgeA;
+    //  else if(_BackEdgeB.first == iEdge)
+    //    dEdge = _BackEdgeB;
+    //  return const_edge_iterator(_FrontEdgeA, _FrontEdgeB, _BackEdgeA, _BackEdgeB, dEdge);
+}
+ 
+ViewVertexInternal::orientedViewEdgeIterator TVertex::edgesBegin() {
+  return ViewVertexInternal::orientedViewEdgeIterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+}
+ViewVertexInternal::orientedViewEdgeIterator TVertex::edgesEnd() {
+ return ViewVertexInternal::orientedViewEdgeIterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.end());
+}
+ViewVertexInternal::orientedViewEdgeIterator TVertex::edgesIterator(ViewEdge *iEdge) {
+  for(edge_pointers_container::iterator it=_sortedEdges.begin(), itend=_sortedEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((*it)->first == iEdge)
+        return ViewVertexInternal::orientedViewEdgeIterator(_sortedEdges.begin(), _sortedEdges.end(), it);
+    }
+    return ViewVertexInternal::orientedViewEdgeIterator(_sortedEdges.begin(), _sortedEdges.end(), _sortedEdges.begin());
+}
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             NonTVertex         */ 
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+void NonTVertex::AddOutgoingViewEdge(ViewEdge * iVEdge){
+  // let's keep the viewedges ordered in CCW order 
+  // in the 2D image plan
+  directedViewEdge idve(iVEdge, false);
+  if(!_ViewEdges.empty()){
+    edges_container::iterator dve = _ViewEdges.begin(), dveend = _ViewEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(*dve, idve)){
+      ++dve;
+    }
+    _ViewEdges.insert(dve, idve);
+  }
+  else
+    _ViewEdges.push_back(idve);
+}
+
+void NonTVertex::AddIncomingViewEdge(ViewEdge * iVEdge){
+  // let's keep the viewedges ordered in CCW order 
+  // in the 2D image plan
+  directedViewEdge idve(iVEdge, true);
+  if(!_ViewEdges.empty()){
+    edges_container::iterator dve = _ViewEdges.begin(), dveend = _ViewEdges.end();
+    while((dve!=dveend) && ViewEdgeComp(*dve, idve)){
+      ++dve;
+    }
+    _ViewEdges.insert(dve, idve);
+  }
+  else
+    _ViewEdges.push_back(idve);
+}
+
+/*! iterators access */
+ViewVertex::edge_iterator NonTVertex::edges_begin()
+{ 
+    return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
+}
+ViewVertex::const_edge_iterator NonTVertex::edges_begin() const
+{ 
+    return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
+}
+ViewVertex::edge_iterator NonTVertex::edges_end()
+{
+    return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
+}
+ViewVertex::const_edge_iterator NonTVertex::edges_end() const
+{
+    return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
+}
+ViewVertex::edge_iterator NonTVertex::edges_iterator(ViewEdge *iEdge)
+{
+    for(edges_container::iterator it=_ViewEdges.begin(), itend=_ViewEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((it)->first == iEdge)
+        return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), it);
+    }
+    return edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());   
+}
+ViewVertex::const_edge_iterator NonTVertex::edges_iterator(ViewEdge *iEdge) const
+{
+    for(edges_container::const_iterator it=_ViewEdges.begin(), itend=_ViewEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((it)->first == iEdge)
+        return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), it);
+    }
+    return const_edge_iterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());   
+}
+
+ViewVertexInternal::orientedViewEdgeIterator NonTVertex::edgesBegin() {
+  return ViewVertexInternal::orientedViewEdgeIterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());
+}
+ViewVertexInternal::orientedViewEdgeIterator NonTVertex::edgesEnd() {
+ return ViewVertexInternal::orientedViewEdgeIterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.end());
+}
+ViewVertexInternal::orientedViewEdgeIterator NonTVertex::edgesIterator(ViewEdge *iEdge) {
+  for(edges_container::iterator it=_ViewEdges.begin(), itend=_ViewEdges.end();
+    it!=itend;
+    it++)
+    {
+      if((it)->first == iEdge)
+        return ViewVertexInternal::orientedViewEdgeIterator(_ViewEdges.begin(), _ViewEdges.end(), it);
+    }
+    return ViewVertexInternal::orientedViewEdgeIterator(_ViewEdges.begin(), _ViewEdges.end(), _ViewEdges.begin());   
+}
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+real ViewEdge::getLength2D() const 
+{
+  float length = 0.f;
+  ViewEdge::const_fedge_iterator itlast = fedge_iterator_last();
+  ViewEdge::const_fedge_iterator it = fedge_iterator_begin(), itend=fedge_iterator_end();
+  Vec2r seg;
+  do{
+    seg = Vec2r((*it)->orientation2d()[0], (*it)->orientation2d()[1]);
+    length += seg.norm();
+    ++it;
+  }while((it!=itend) && (it!=itlast));
+  return length;
+}
+
+
+//! view edge iterator
+ViewEdge::edge_iterator ViewEdge::ViewEdge_iterator() {return edge_iterator(this);}
+ViewEdge::const_edge_iterator ViewEdge::ViewEdge_iterator() const {return const_edge_iterator((ViewEdge*)this);}
+//! feature edge iterator
+ViewEdge::fedge_iterator ViewEdge::fedge_iterator_begin() {return fedge_iterator(this->_FEdgeA, this->_FEdgeB);}
+ViewEdge::const_fedge_iterator ViewEdge::fedge_iterator_begin() const {return const_fedge_iterator(this->_FEdgeA, this->_FEdgeB);}
+ViewEdge::fedge_iterator ViewEdge::fedge_iterator_last() {return fedge_iterator(this->_FEdgeB, this->_FEdgeB);}
+ViewEdge::const_fedge_iterator ViewEdge::fedge_iterator_last() const {return const_fedge_iterator(this->_FEdgeB, this->_FEdgeB);}
+ViewEdge::fedge_iterator ViewEdge::fedge_iterator_end() {return fedge_iterator(0, this->_FEdgeB);}
+ViewEdge::const_fedge_iterator ViewEdge::fedge_iterator_end() const {return const_fedge_iterator(0, this->_FEdgeB);}
+//! embedding vertex iterator
+ViewEdge::const_vertex_iterator ViewEdge::vertices_begin() const {return const_vertex_iterator(this->_FEdgeA->vertexA(), 0, _FEdgeA);}
+ViewEdge::vertex_iterator ViewEdge::vertices_begin() {return vertex_iterator(this->_FEdgeA->vertexA(), 0, _FEdgeA);}
+ViewEdge::const_vertex_iterator ViewEdge::vertices_last() const {return const_vertex_iterator(this->_FEdgeB->vertexB(), _FEdgeB, 0);}
+ViewEdge::vertex_iterator ViewEdge::vertices_last() {return vertex_iterator(this->_FEdgeB->vertexB(), _FEdgeB, 0);}
+ViewEdge::const_vertex_iterator ViewEdge::vertices_end() const {return const_vertex_iterator(0, _FEdgeB, 0);}
+ViewEdge::vertex_iterator ViewEdge::vertices_end() {return vertex_iterator(0, _FEdgeB, 0);}
+
+
+Interface0DIterator ViewEdge::verticesBegin() {
+  Interface0DIterator ret(new ViewEdgeInternal::SVertexIterator(this->_FEdgeA->vertexA(), this->_FEdgeA->vertexA(), 0, _FEdgeA, 0.f));
+  return ret;
+}
+
+Interface0DIterator ViewEdge::verticesEnd() {
+  Interface0DIterator ret(new ViewEdgeInternal::SVertexIterator(0, this->_FEdgeA->vertexA(), _FEdgeB, 0, getLength2D())); 
+  return ret;
+}
+
+Interface0DIterator ViewEdge::pointsBegin(float t) {
+  return verticesBegin();
+}
+
+Interface0DIterator ViewEdge::pointsEnd(float t) {
+  return verticesEnd();
+}
+
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewShape          */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+ViewShape::~ViewShape()
+{
+  _Vertices.clear();
+
+  if(!(_Edges.empty()))
+  {
+    for(vector<ViewEdge*>::iterator e=_Edges.begin(), eend=_Edges.end();
+    e!=eend;
+    e++)
+    {
+      delete (*e);
+    }
+    _Edges.clear();
+  }
+
+  if(0 != _SShape)
+  {
+    delete _SShape;
+    _SShape = 0;
+  }
+}
+
+void ViewShape::RemoveEdge(ViewEdge * iViewEdge)
+{
+  FEdge * fedge = iViewEdge->fedgeA();
+  for(vector<ViewEdge*>::iterator ve=_Edges.begin(),veend=_Edges.end();
+  ve!=veend;
+  ve++)
+  {
+    if(iViewEdge == (*ve))
+    {
+      _Edges.erase(ve);
+      _SShape->RemoveEdge(fedge);
+      break;
+    }
+  }
+}
+
+void ViewShape::RemoveVertex(ViewVertex * iViewVertex)
+{
+  for(vector<ViewVertex*>::iterator vv=_Vertices.begin(), vvend=_Vertices.end();
+  vv!=vvend;
+  vv++)
+  {
+    if(iViewVertex == (*vv))
+    {
+      _Vertices.erase(vv);
+      break;
+    }
+  }
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+void ViewEdge::UpdateFEdges()
+{
+  FEdge *currentEdge = _FEdgeA;
+  do
+  {
+    currentEdge->setViewEdge(this);
+    currentEdge = currentEdge->nextEdge();
+  }while((currentEdge != NULL) && (currentEdge!= _FEdgeB));
+  // last one
+  _FEdgeB->setViewEdge(this);
+
+}
diff --git a/source/blender/freestyle/intern/view_map/ViewMap.h b/source/blender/freestyle/intern/view_map/ViewMap.h
new file mode 100755
index 00000000000..2691da20057
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMap.h
@@ -0,0 +1,1490 @@
+//
+//  Filename         : ViewMap.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes to define a View Map (ViewVertex, ViewEdge, etc.)
+//  Date of creation : 03/09/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAP_H
+# define VIEWMAP_H
+
+# include "../system/BaseIterator.h"
+# include "../system/FreestyleConfig.h"
+# include "../geometry/GeomUtils.h"
+# include "Interface0D.h"
+# include "Interface1D.h"
+# include "Silhouette.h" // defines the embedding
+# include <map>
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewMap            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+/*  Density
+    Mean area depth value
+    distance to a point
+    */
+
+class ViewVertex;
+class ViewEdge;
+class ViewShape;
+class TVertex;
+
+/*! Class defining the ViewMap.*/
+class LIB_VIEW_MAP_EXPORT ViewMap 
+{
+public:
+
+  typedef vector<ViewEdge*> viewedges_container;
+  typedef vector<ViewVertex*> viewvertices_container;
+  typedef vector<ViewShape*> viewshapes_container;
+  typedef vector<SVertex*> svertices_container;
+  typedef vector<FEdge*> fedges_container;
+  typedef map<int,int> id_to_index_map;
+
+private:
+
+  static ViewMap *_pInstance;
+  viewshapes_container _VShapes; // view shapes
+  viewedges_container _VEdges; // view edges
+  viewvertices_container _VVertices; // view vertices
+  fedges_container _FEdges; // feature edges (embedded edges)
+  svertices_container _SVertices; // embedded vertices
+  BBox<Vec3r> _scene3DBBox;
+  id_to_index_map _shapeIdToIndex; // Mapping between the WShape or VShape id to the VShape index in the 
+                                // _VShapes vector. Used in the method viewShape(int id) to access a shape from its id.
+
+public:
+
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void* userdata;
+
+  /*! Default constructor. */
+  ViewMap() {
+    _pInstance = this;
+    userdata = 0;
+  }
+  /*! Destructor. */
+  virtual ~ViewMap();
+
+  /*! Gets the viewedge the nearest to the 
+   *  2D position specified as argument
+   */
+  const ViewEdge * GetClosestViewEdge(real x, real y) const ;
+
+  /*! Gets the Fedge the nearest to the 
+   *  2D position specified as argument
+   */
+  const FEdge * GetClosestFEdge(real x, real y) const ;
+
+  /* accessors */
+  /*! The ViewMap is a singleton class. This static method
+   * returns the instance of the ViewMap.
+   */
+  static inline ViewMap * getInstance() {return _pInstance;}
+  /* Returns the list of ViewShapes of the scene. */
+  inline viewshapes_container& ViewShapes() {return _VShapes;}
+  /* Returns the list of ViewEdges of the scene. */
+  inline viewedges_container& ViewEdges() {return _VEdges;}
+  /* Returns the list of ViewVertices of the scene. */
+  inline viewvertices_container& ViewVertices() {return _VVertices;}
+  /* Returns the list of FEdges of the scene. */
+  inline fedges_container& FEdges() {return _FEdges;}
+  /* Returns the list of SVertices of the scene. */
+  inline svertices_container& SVertices() {return _SVertices;}
+  /* Returns an iterator pointing onto the first ViewEdge of the list. */
+  inline viewedges_container::iterator viewedges_begin() {return _VEdges.begin();}
+  inline viewedges_container::iterator viewedges_end() {return _VEdges.end();}
+  inline int viewedges_size() {return _VEdges.size();}
+  ViewShape * viewShape(unsigned index);
+  id_to_index_map& shapeIdToIndexMap() {return _shapeIdToIndex;}
+
+  /*! Returns the scene 3D bounding box. */
+  inline BBox<Vec3r> getScene3dBBox() const {return _scene3DBBox;}
+
+  /* modifiers */
+  void AddViewShape(ViewShape *iVShape);
+  inline void AddViewEdge(ViewEdge *iVEdge) {_VEdges.push_back(iVEdge);}
+  inline void AddViewVertex(ViewVertex *iVVertex) {_VVertices.push_back(iVVertex);}
+  inline void AddFEdge(FEdge *iFEdge) {_FEdges.push_back(iFEdge);}
+  inline void AddSVertex(SVertex *iSVertex) {_SVertices.push_back(iSVertex);}
+  /*! Sets the scene 3D bounding box. */
+  inline void setScene3dBBox(const BBox<Vec3r>& bbox) {_scene3DBBox=bbox;}
+
+  /* Creates a T vertex in the view map.
+   *  A T vertex is the intersection between 2
+   *  FEdges (before these ones are splitted).
+   *  The TVertex is a 2D intersection but it 
+   *  corresponds to a 3D point on each of the 2 FEdges.
+   *    iA3D
+   *      The 3D coordinates of the point corresponding 
+   *      to the intersection on the first edge.
+   *    iA2D
+   *      The x,y,z 2D coordinates of the projection 
+   *      of iA3D
+   *    iFEdgeA
+   *      The first FEdge
+   *    iB3D
+   *      The 3D coordinates of the point corresponding 
+   *      to the intersection on the second edge.
+   *    iB2D
+   *      The x,y,z 2D coordinates of the projection 
+   *      of iB3D
+   *    iFEdgeB
+   *      The second FEdge   
+   *    id
+   *      The id that must be given to that TVertex
+   */
+  TVertex* CreateTVertex(const Vec3r& iA3D, const Vec3r& iA2D, FEdge *iFEdgeA,
+                         const Vec3r& iB3D, const Vec3r& iB2D, FEdge *iFEdgeB,
+                         const Id& id);
+
+  /* Updates the structures to take into account the fact 
+   *  that a SVertex must now be considered as a ViewVertex 
+   *    iVertex
+   *      The SVertex on top of which the ViewVertex is built (it is necessarily
+   *      a NonTVertex because it is a SVertex)
+   *    newViewEdges
+   *      The new ViewEdges that must be add to the ViewMap
+   */
+  ViewVertex * InsertViewVertex(SVertex *iVertex, vector<ViewEdge*>& newViewEdges);
+
+  /* connects a FEdge to the graph trough a SVertex */
+  //FEdge * Connect(FEdge *ioEdge, SVertex *ioVertex);
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewVertex         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+class ViewEdge;
+class SShape;
+
+namespace ViewVertexInternal {
+  class edge_const_traits;
+  class edge_nonconst_traits;
+  template<class Traits> class edge_iterator_base ;
+  class orientedViewEdgeIterator;
+} // end of namespace ViewEdgeInternal
+/*! Class to define a view vertex 
+ *  A view vertex is a feature vertex corresponding 
+ *  to a point of the image graph, where the characteristics of an 
+ *  edge might change (nature, visibility, ...).
+ *  A ViewVertex can be of two kinds: a TVertex when
+ *  it corresponds to the intersection between two
+ *  ViewEdges or a NonTVertex when it corresponds to a
+ *  vertex of the initial input mesh (it is the case
+ *  for vertices such as corners for example).
+ *  Thus, this class can be specialized into two classes,
+ *  the TVertex class and the NonTVertex class.
+ */
+class LIB_VIEW_MAP_EXPORT ViewVertex : public Interface0D
+{
+public: // Implementation of Interface0D
+
+  /*! Returns the string "ViewVertex" .*/
+  virtual string getExactTypeName() const {
+    return "ViewVertex";
+  }
+
+public:  
+  friend class ViewShape;
+  typedef pair<ViewEdge*, bool> directedViewEdge; // if bool = true, the ViewEdge is incoming
+
+  typedef vector<directedViewEdge> edges_container;
+
+  typedef ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits> edge_iterator;
+  typedef ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits> const_edge_iterator;
+
+private:
+
+  Nature::VertexNature _Nature;
+
+public:
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void * userdata;
+  /*! Default constructor.*/
+  inline ViewVertex() {userdata = 0;_Nature = Nature::VIEW_VERTEX; }
+  inline ViewVertex(Nature::VertexNature nature) {
+    userdata = 0;
+    _Nature = Nature::VIEW_VERTEX | nature;
+  }
+
+protected:
+  /*! Copy constructor. */
+  inline ViewVertex(ViewVertex& iBrother)
+  {
+    _Nature = iBrother._Nature;
+    iBrother.userdata = this;
+    userdata = 0;
+  }
+  /*! Cloning method. */
+  virtual ViewVertex * duplicate() = 0;
+  
+public:
+  /*! Destructor. */
+  virtual ~ViewVertex() {}
+
+  /* accessors */
+  /*! Returns the nature of the vertex .*/
+  virtual Nature::VertexNature getNature() const {
+    return _Nature;
+  }
+
+  /* modifiers */
+  /*! Sets the nature of the vertex. */
+  inline void setNature(Nature::VertexNature iNature) {_Nature = iNature;}
+  
+  /* Replaces old edge by new edge */
+  virtual void Replace(ViewEdge *, ViewEdge *) {}
+
+public:
+  
+  /* iterators access */
+  // allows iteration on the edges that comes from/goes to 
+  // this vertex in CCW order (order defined in 2D in the image plan)
+  virtual edge_iterator edges_begin() = 0;
+  virtual const_edge_iterator edges_begin() const = 0;
+  virtual edge_iterator edges_end() = 0;
+  virtual const_edge_iterator edges_end() const = 0;
+  virtual edge_iterator edges_iterator(ViewEdge *iEdge) = 0;
+  virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const  = 0;
+
+
+  // Iterator access
+  /*! Returns an iterator over the ViewEdges that goes to or comes from
+   *  this ViewVertex pointing to the first ViewEdge of the list.
+   *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
+   *  and to get the orientation for each ViewEdge (incoming/outgoing).
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() = 0;
+
+  /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
+   *  pointing after the last ViewEdge.
+   */
+	virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() = 0;
+
+  /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
+   *  given as argument.
+   */
+	virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) = 0;
+  
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             TVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/*! class to define a T vertex, i.e. an intersection between 
+ *  two edges. 
+ *  It points towards 2 SVertex and 4 View edges.
+ *  Among these ViewEdges, 2 are front and 2 are back.
+ *  Basically the front edge hides part of the back edge.
+ *  So, among the back edges, 1 is of invisibility n
+ *  and the other of visibility n+1
+ */
+class LIB_VIEW_MAP_EXPORT TVertex : public ViewVertex
+{
+public:
+  typedef vector<directedViewEdge*> edge_pointers_container;
+public: // Implementation of Interface0D
+
+  /*! Returns the string "TVertex" .*/
+  virtual string getExactTypeName() const {
+    return "TVertex";
+  }
+
+  // Data access methods
+  /* Returns the 3D x coordinate of the vertex .
+   * Ambiguous in this case.
+   */
+  virtual real getX() const {
+    cerr << "Warning: getX() undefined for this point" << endl;
+    return _FrontSVertex->point3D().x();
+  }
+
+  virtual real getY() const {
+    cerr << "Warning: getX() undefined for this point" << endl;
+    return _FrontSVertex->point3D().y();
+  }
+
+  virtual real getZ() const {
+    cerr << "Warning: getX() undefined for this point" << endl;
+    return _FrontSVertex->point3D().z();
+  }
+
+  /*!  Returns the 3D point. */ 
+  virtual Vec3f getPoint3D() const {
+    cerr << "Warning: getPoint3D() undefined for this point" << endl;
+    return _FrontSVertex->getPoint3D();
+  }
+
+  /*! Returns the projected 3D  x coordinate of the vertex .*/
+  virtual real getProjectedX() const {
+    return _FrontSVertex->point2D().x();
+  }
+
+  /*! Returns the projected 3D  y coordinate of the vertex .*/
+  virtual real getProjectedY() const {
+    return _FrontSVertex->point2D().y();
+  }
+
+  virtual real getProjectedZ() const {
+    return _FrontSVertex->point2D().z();
+  }
+
+  /*!  Returns the 2D point. */ 
+  virtual Vec2f getPoint2D() const {
+    return _FrontSVertex->getPoint2D();
+  }
+
+  /*! Returns the Id of the TVertex .*/
+  virtual Id getId() const {
+    return _Id;
+  }
+
+  /*! Cast the Interface0D in SVertex if it can be. */ 
+  // it can't
+  /*! Cast the Interface0D in ViewVertex if it can be. */ 
+  virtual ViewVertex * castToViewVertex(){
+    return this;
+  }
+
+  /*! Cast the Interface0D in TVertex if it can be. */ 
+  virtual TVertex * castToTVertex(){
+    return this;
+  }
+
+private:
+  SVertex  *_FrontSVertex;
+  SVertex  *_BackSVertex;
+  directedViewEdge _FrontEdgeA;
+  directedViewEdge _FrontEdgeB;
+  directedViewEdge _BackEdgeA;
+  directedViewEdge _BackEdgeB;
+  Id _Id; // id to identify t vertices . these id will be negative in order not to be mixed with NonTVertex ids.
+  edge_pointers_container _sortedEdges; // the list of the four ViewEdges, ordered in CCW order (in the image plan)
+
+
+public:
+  /*! Default constructor.*/
+  inline TVertex() : ViewVertex(Nature::T_VERTEX) 
+  {
+    _FrontSVertex = 0;
+    _BackSVertex = 0;
+    _FrontEdgeA.first = 0;
+    _FrontEdgeB.first = 0;
+    _BackEdgeA.first = 0;
+    _BackEdgeB.first = 0;
+
+  }
+
+  inline TVertex(SVertex *svFront, SVertex *svBack)
+    : ViewVertex(Nature::T_VERTEX)
+  {
+    _FrontSVertex = svFront;
+    _BackSVertex = svBack;
+    _FrontEdgeA.first = 0;
+    _FrontEdgeB.first = 0;
+    _BackEdgeA.first = 0;
+    _BackEdgeB.first = 0;
+    svFront->setViewVertex(this);
+    svBack->setViewVertex(this);
+  }
+
+protected:
+  /*! Copy constructor. */
+  inline TVertex(TVertex& iBrother)
+    : ViewVertex(iBrother)
+  {
+    _FrontSVertex = iBrother._FrontSVertex;
+    _BackSVertex = iBrother._BackSVertex;
+    _FrontEdgeA = iBrother._FrontEdgeA;
+    _FrontEdgeB = iBrother._FrontEdgeB;
+    _BackEdgeA = iBrother._BackEdgeA;
+    _BackEdgeB = iBrother._BackEdgeB;
+    _sortedEdges = iBrother._sortedEdges;
+  }
+
+  /*! Cloning method. */
+  virtual ViewVertex * duplicate()
+  {
+    TVertex *clone = new TVertex(*this);
+    return clone;
+  }
+
+public:
+  /* accessors */
+  /*! Returns the SVertex that is closer to the viewpoint. */
+  inline SVertex  *frontSVertex() {return _FrontSVertex;}
+  /*! Returns the SVertex that is further away from the viewpoint. */
+  inline SVertex  *backSVertex() {return _BackSVertex;}
+  inline directedViewEdge& frontEdgeA() {return _FrontEdgeA;}
+  inline directedViewEdge& frontEdgeB() {return _FrontEdgeB;}
+  inline directedViewEdge& backEdgeA() {return _BackEdgeA;}
+  inline directedViewEdge& backEdgeB() {return _BackEdgeB;}
+  
+  /* modifiers */
+  /*! Sets the SVertex that is closer to the viewpoint. */
+  inline void setFrontVertex(SVertex  *iFrontSVertex) {_FrontSVertex = iFrontSVertex;_FrontSVertex->setViewVertex(this);}
+  /*! Sets the SVertex that is further away from the viewpoint. */
+  inline void setBackSVertex(SVertex  *iBackSVertex) {_BackSVertex = iBackSVertex;_BackSVertex->setViewVertex(this);}
+  void setFrontEdgeA(ViewEdge *iFrontEdgeA, bool incoming=true);
+  void setFrontEdgeB(ViewEdge *iFrontEdgeB, bool incoming=true) ;
+  void setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming=true);
+  void setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming=true) ;
+  /*! Sets the Id. */
+  inline void setId(const Id& iId) {_Id = iId;}
+  
+  /*! Returns the SVertex (among the 2) belonging to the FEdge iFEdge */
+  inline SVertex * GetSVertex(FEdge *iFEdge)
+  {
+    const vector<FEdge*>& vfEdges = _FrontSVertex->fedges();
+    vector<FEdge*>::const_iterator fe,fend;
+    for(fe=vfEdges.begin(),fend=vfEdges.end();
+    fe!=fend;
+    fe++)
+    {
+      if((*fe) == iFEdge)
+        return _FrontSVertex;
+    }
+
+    const vector<FEdge*>& vbEdges = _BackSVertex->fedges();
+    for(fe=vbEdges.begin(),fend=vbEdges.end();
+    fe!=fend;
+    fe++)
+    {
+      if((*fe) == iFEdge)
+        return _BackSVertex;
+    }
+    return 0;
+  }
+
+  virtual void Replace(ViewEdge *iOld, ViewEdge *iNew);
+  
+  /*! returns the mate edge of iEdgeA.
+   *  For example, if iEdgeA is frontEdgeA, 
+   *  then frontEdgeB is returned. If iEdgeA is 
+   *  frontEdgeB then frontEdgeA is returned.
+   *  Same for back edges
+   */
+  virtual ViewEdge * mate(ViewEdge* iEdgeA)
+  {
+    if(iEdgeA == _FrontEdgeA.first)
+      return _FrontEdgeB.first;
+    if(iEdgeA == _FrontEdgeB.first)
+      return _FrontEdgeA.first;
+    if(iEdgeA == _BackEdgeA.first)
+      return _BackEdgeB.first;
+    if(iEdgeA == _BackEdgeB.first)
+      return _BackEdgeA.first;
+    return 0;
+  }
+  
+  /* iterators access */
+  virtual edge_iterator edges_begin();
+  virtual const_edge_iterator edges_begin() const;
+  virtual edge_iterator edges_end();
+  virtual const_edge_iterator edges_end() const;
+  virtual edge_iterator edges_iterator(ViewEdge *iEdge);
+  virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const;
+
+  /*! Returns an iterator over the ViewEdges that goes to or comes from
+   *  this ViewVertex pointing to the first ViewEdge of the list.
+   *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
+   *  and to get the orientation for each ViewEdge (incoming/outgoing).
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() ;
+  /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
+   *  pointing after the last ViewEdge.
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() ;
+  /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
+   *  given as argument.
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) ;
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             NonTVertex         */ 
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+// (non T vertex)
+/*! View vertex for corners, cusps, etc...
+ *  Associated to a single SVertex.
+ *  Can be associated to 2 or several view edges
+ */
+class LIB_VIEW_MAP_EXPORT NonTVertex : public ViewVertex
+{
+public:
+  typedef vector<directedViewEdge> edges_container;
+
+public: // Implementation of Interface0D
+
+  /*! Returns the string "ViewVertex" .*/
+  virtual string getExactTypeName() const {
+    return "NonTVertex";
+  }
+
+  // Data access methods
+  /*! Returns the 3D x coordinate of the vertex .*/
+  virtual real getX() const {
+    return _SVertex->point3D().x();
+  }
+  /*! Returns the 3D y coordinate of the vertex .*/
+  virtual real getY() const {
+    return _SVertex->point3D().y();
+  }
+
+  /*! Returns the 3D z coordinate of the vertex .*/
+  virtual real getZ() const {
+    return _SVertex->point3D().z();
+  }
+
+  /*!  Returns the 3D point. */ 
+  virtual Vec3f getPoint3D() const {
+    return _SVertex->getPoint3D();
+  }
+
+  /*! Returns the projected 3D  x coordinate of the vertex .*/
+  virtual real getProjectedX() const {
+    return _SVertex->point2D().x();
+  }
+
+  /*! Returns the projected 3D  y coordinate of the vertex .*/
+  virtual real getProjectedY() const {
+    return _SVertex->point2D().y();
+  }
+
+  /*! Returns the projected 3D  z coordinate of the vertex .*/
+  virtual real getProjectedZ() const {
+    return _SVertex->point2D().z();
+  }
+
+  /*!  Returns the 2D point. */ 
+  virtual Vec2f getPoint2D() const {
+    return _SVertex->getPoint2D();
+  }
+
+  /*! Returns the Id of the vertex .*/
+  virtual Id getId() const {
+    return _SVertex->getId();
+  }
+
+  /*! Cast the Interface0D in SVertex if it can be. */ 
+  virtual SVertex * castToSVertex(){
+    return _SVertex;
+  }
+
+  /*! Cast the Interface0D in ViewVertex if it can be. */ 
+  virtual ViewVertex * castToViewVertex(){
+    return this;
+  }
+
+  /*! Cast the Interface0D in NonTVertex if it can be. */ 
+  virtual NonTVertex * castToNonTVertex(){
+    return this;
+  }
+
+private:
+  SVertex *_SVertex;
+  edges_container _ViewEdges; 
+public:
+  /*! Default constructor.*/
+  inline NonTVertex() : ViewVertex(Nature::NON_T_VERTEX) { _SVertex = 0; }
+  /*! Builds a NonTVertex from a SVertex. */
+  inline NonTVertex(SVertex* iSVertex) : ViewVertex(Nature::NON_T_VERTEX)
+  {
+    _SVertex = iSVertex;
+    _SVertex->setViewVertex(this);
+  }
+protected:
+  /*! Copy constructor. */
+  inline NonTVertex(NonTVertex& iBrother)
+    : ViewVertex(iBrother)
+  {
+    _SVertex = iBrother._SVertex;
+    _SVertex->setViewVertex(this);
+    _ViewEdges = iBrother._ViewEdges;
+  }
+  /*! Cloning method. */
+  virtual ViewVertex * duplicate()
+  {
+    NonTVertex *clone = new NonTVertex(*this);
+    return clone;
+  }
+public:
+  /*! destructor. */
+  virtual ~NonTVertex() {}
+  
+  /* accessors */
+  /*! Returns the SVertex on top of which this NonTVertex is built. */
+  inline SVertex * svertex() {return _SVertex;}
+  inline edges_container& viewedges() {return _ViewEdges;}
+  
+  /* modifiers */
+  /*! Sets the SVertex on top of which this NonTVertex is built. */
+  inline void setSVertex(SVertex *iSVertex) {_SVertex = iSVertex;_SVertex->setViewVertex(this);}
+  inline void setViewEdges(const vector<directedViewEdge>& iViewEdges) {_ViewEdges = iViewEdges;}
+  void AddIncomingViewEdge(ViewEdge * iVEdge) ;
+  void AddOutgoingViewEdge(ViewEdge * iVEdge) ;
+  inline void AddViewEdge(ViewEdge * iVEdge, bool incoming=true) {
+    if(incoming)
+      AddIncomingViewEdge(iVEdge);
+    else
+      AddOutgoingViewEdge(iVEdge);
+  }
+  /* Replaces old edge by new edge */
+  virtual void Replace(ViewEdge *iOld, ViewEdge *iNew)
+  {
+    
+      edges_container::iterator insertedve;
+      for(edges_container::iterator ve=_ViewEdges.begin(),vend=_ViewEdges.end();
+      ve!=vend;
+      ve++)
+      {
+        if((ve)->first == iOld)
+        {
+          insertedve = _ViewEdges.insert(ve, directedViewEdge(iNew, ve->second));// inserts e2 before ve.
+                                              // returns an iterator pointing toward e2. ve is invalidated.
+          // we want to remove e1, but we can't use ve anymore:
+          insertedve++; // insertedve points now to e1
+          _ViewEdges.erase(insertedve);
+          return;
+        }
+      } 
+  }    
+
+  
+  /* iterators access */
+  virtual edge_iterator edges_begin();
+  virtual const_edge_iterator edges_begin() const;
+  virtual edge_iterator edges_end();
+  virtual const_edge_iterator edges_end() const;
+  virtual edge_iterator edges_iterator(ViewEdge *iEdge);
+  virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const;
+
+  /*! Returns an iterator over the ViewEdges that goes to or comes from
+   *  this ViewVertex pointing to the first ViewEdge of the list.
+   *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
+   *  and to get the orientation for each ViewEdge (incoming/outgoing).
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() ;
+  /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
+   *  pointing after the last ViewEdge.
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() ;
+  /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
+   *  given as argument.
+   */
+  virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) ;
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/* Geometry(normals...)
+  Nature of edges
+  2D spaces (1or2, material, z...)
+  Parent Shape
+  3D Shading, material
+  Importance
+  Occluders
+  */
+class ViewShape;
+
+namespace ViewEdgeInternal {
+  template<class Traits> class edge_iterator_base ;
+  template<class Traits> class fedge_iterator_base ;
+  template<class Traits> class vertex_iterator_base ;
+} // end of namespace ViewEdgeInternal
+
+/*! Class defining a ViewEdge. A ViewEdge in an edge
+ *  of the image graph. it connnects two ViewVertex.
+ *  It is made by connecting a set of FEdges.
+ */
+class LIB_VIEW_MAP_EXPORT ViewEdge : public Interface1D
+{
+public: // Implementation of Interface0D
+
+  /*! Returns the string "ViewEdge" .*/
+  virtual string getExactTypeName() const {
+    return "ViewEdge";
+  }
+
+  // Data access methods
+  /*! Returns the Id of the vertex .*/
+  virtual Id getId() const {
+    return _Id;
+  }
+
+  /*! Returns the nature of the ViewEdge. */
+  virtual Nature::EdgeNature getNature() const {
+    return _Nature;
+  }
+
+public:
+  
+  typedef SVertex vertex_type;
+  friend class ViewShape;
+  // for ViewEdge iterator
+  typedef ViewEdgeInternal::edge_iterator_base<Nonconst_traits<ViewEdge*> > edge_iterator;
+  typedef ViewEdgeInternal::edge_iterator_base<Const_traits<ViewEdge*> > const_edge_iterator;
+  // for fedge iterator
+  typedef ViewEdgeInternal::fedge_iterator_base<Nonconst_traits<FEdge*> > fedge_iterator;
+  typedef ViewEdgeInternal::fedge_iterator_base<Const_traits<FEdge*> > const_fedge_iterator;
+  // for svertex iterator
+  typedef ViewEdgeInternal::vertex_iterator_base<Nonconst_traits<SVertex*> > vertex_iterator;
+  typedef ViewEdgeInternal::vertex_iterator_base<Const_traits<SVertex*> > const_vertex_iterator;
+private:
+
+  ViewVertex * __A; // edge starting vertex
+  ViewVertex * __B; // edge ending vertex
+  Nature::EdgeNature _Nature; // nature of view edge
+  ViewShape *_Shape; // shape to which the view edge belongs
+  FEdge * _FEdgeA; // first edge of the embedded fedges chain
+  FEdge * _FEdgeB; // last edge of the embedded fedges chain
+  Id _Id;
+  unsigned _ChainingTimeStamp;
+  ViewShape *_aShape; // The silhouette view edge separates 2 2D spaces. The one on the left is 
+  // necessarly the Shape _Shape (the one to which this edge belongs to)
+  // and _aShape is the one on its right // NON GERE PAR LE COPY CONSTRUCTEUR
+  int _qi;
+  vector<ViewShape*> _Occluders;
+
+  // tmp
+  Id * _splittingId;
+
+public:
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void * userdata;
+  /*! Default constructor.*/
+  inline ViewEdge() {
+    __A=0;
+    __B=0;
+    _FEdgeA = 0;
+    _FEdgeB = 0;
+    _ChainingTimeStamp = 0;
+    _qi = 0;
+    _aShape=0;
+    userdata = 0;
+    _splittingId = 0;
+  }
+  inline ViewEdge(ViewVertex* iA, ViewVertex *iB)
+  {
+    __A = iA;
+    __B = iB;
+    _FEdgeA = 0;
+    _FEdgeB = 0;
+    _Shape = 0;
+    _ChainingTimeStamp = 0;
+    _aShape = 0;
+    _qi = 0;
+    userdata = 0;
+    _splittingId = 0;
+  }
+  inline ViewEdge(ViewVertex* iA, ViewVertex *iB, FEdge *iFEdgeA)
+  {
+    __A = iA;
+    __B = iB;
+    _FEdgeA = iFEdgeA;
+    _FEdgeB = 0;
+    _Shape = 0;
+    _ChainingTimeStamp = 0;
+    _aShape = 0;
+    _qi = 0;
+    userdata = 0;
+    _splittingId = 0;
+  }
+  inline ViewEdge(ViewVertex* iA, ViewVertex *iB, FEdge *iFEdgeA, FEdge *iFEdgeB, ViewShape *iShape)
+  {
+    __A = iA;
+    __B = iB;
+    _FEdgeA = iFEdgeA;
+    _FEdgeB = iFEdgeB;
+    _Shape = iShape;
+    _ChainingTimeStamp = 0;
+    _aShape = 0;
+    _qi = 0;
+    userdata = 0;
+    _splittingId = 0;
+    UpdateFEdges(); // tells every FEdge between iFEdgeA and iFEdgeB that this is theit ViewEdge
+  }
+protected:
+  /*! Copy constructor. */
+  inline ViewEdge(ViewEdge& iBrother)
+  {
+    __A = iBrother.__A;
+    __B = iBrother.__B;
+    _FEdgeA = iBrother._FEdgeA;
+    _FEdgeB = iBrother._FEdgeB;
+    _Nature = iBrother._Nature;
+    _Shape = 0;
+    _Id = iBrother._Id;
+    _ChainingTimeStamp = iBrother._ChainingTimeStamp;
+    _aShape = iBrother._aShape;
+    _qi = iBrother._qi;
+    _splittingId = 0;
+    iBrother.userdata = this;
+    userdata = 0;
+  }
+  /*! Cloning method. */
+  virtual ViewEdge * duplicate()
+  {
+    ViewEdge *clone = new ViewEdge(*this);
+    return clone;
+  }
+
+public:
+  /*! Destructor. */
+  virtual ~ViewEdge()
+  {
+    //    if(0 != _aFace)
+    //    {
+    //      delete _aFace;
+    //      _aFace = 0;
+    //    }
+    // only the last splitted deletes this id
+    if(_splittingId){
+      if(*_splittingId == _Id)
+        delete _splittingId;
+    }
+  }
+
+  /* accessors */
+  /*! Returns the first ViewVertex. */
+  inline  ViewVertex* A()  {return __A;}
+  /*! Returns the second ViewVertex. */
+  inline  ViewVertex* B()  {return __B;}
+  /*! Returns the first FEdge that constitues this ViewEdge. */
+  inline  FEdge* fedgeA()  {return _FEdgeA;}
+  /*! Returns the last FEdge that constitues this ViewEdge. */
+  inline  FEdge* fedgeB()  {return _FEdgeB;}
+  /*! Returns the ViewShape to which this ViewEdge belongs to .*/
+  inline ViewShape * viewShape() {return _Shape;}
+  /*! Returns the shape that is occluded by the ViewShape
+   *  to which this ViewEdge belongs to. If no object is occluded,
+   *  0 is returned.
+   *  \return The occluded ViewShape.
+   */
+  inline ViewShape * aShape() {return _aShape;}
+  /*! Tells whether this ViewEdge forms a closed loop
+   *  or not.
+   */
+  inline bool isClosed() 
+  {
+    if(__B == 0)
+      return true;
+    return false;
+  }
+  /*! Returns the time stamp of this ViewEdge. */
+  inline unsigned getChainingTimeStamp() {return _ChainingTimeStamp;}
+  inline const ViewShape * aShape() const {return _aShape;}
+  inline const ViewShape * bShape() const {return _Shape;}
+  inline vector<ViewShape*>& occluders() {return _Occluders;}
+  inline Id * splittingId() {return _splittingId;}
+  
+  /* modifiers */
+  /*! Sets the first ViewVertex of the ViewEdge. */
+  inline void setA(ViewVertex* iA) { __A = iA; }
+  /*! Sets the last ViewVertex of the ViewEdge. */
+  inline void setB(ViewVertex* iB) { __B = iB; }
+  /*! Sets the nature of the ViewEdge. */
+  inline void setNature(Nature::EdgeNature iNature) { _Nature = iNature; }
+  /*! Sets the first FEdge of the ViewEdge. */
+  inline void setFEdgeA(FEdge* iFEdge) { _FEdgeA = iFEdge; }
+  /*! Sets the last FEdge of the ViewEdge. */
+  inline void setFEdgeB(FEdge* iFEdge) { _FEdgeB = iFEdge; }
+  /*! Sets the ViewShape to which this ViewEdge belongs to.*/
+  inline void setShape(ViewShape *iVShape) 
+  {
+    _Shape = iVShape;
+  }
+  /*! Sets the ViewEdge id. */
+  inline void setId(const Id& id) {_Id = id;}
+  /*! Sets Viewedge to this for all embedded fedges */
+  void UpdateFEdges();
+  /*! Sets the occluded ViewShape */
+  inline void setaShape(ViewShape * iShape) {_aShape = iShape;}
+  /*! Sets the quantitative invisibility value. */
+  inline void setQI(int qi) {_qi = qi;}
+  /*! Sets the time stamp value. */
+  inline void setChainingTimeStamp(unsigned ts) {_ChainingTimeStamp = ts;}
+  inline void AddOccluder(ViewShape *iShape) {_Occluders.push_back(iShape);}
+  inline void setSplittingId(Id * id) {_splittingId = id;}
+
+  /* stroke interface definition */
+  inline bool intersect_2d_area(const Vec2r& iMin, const Vec2r& iMax) const
+  {
+    // parse edges to check if one of them is intersection the region:
+    FEdge * current = _FEdgeA;
+    do
+    {
+      if(GeomUtils::intersect2dSeg2dArea(iMin,iMax, 
+					 Vec2r(current->vertexA()->point2D()[0],current->vertexA()->point2D()[1]),
+					 Vec2r(current->vertexB()->point2D()[0],current->vertexB()->point2D()[1])))
+      
+        return true;
+      current = current->nextEdge();
+    }while((current != 0) && (current != _FEdgeA));
+
+    return false;
+  }
+  inline bool include_in_2d_area(const Vec2r& iMin, const Vec2r& iMax) const
+  {
+    // parse edges to check if all of them are intersection the region:
+    FEdge * current = _FEdgeA;
+    
+    do
+    {
+      if(!GeomUtils::include2dSeg2dArea(iMin,iMax, 
+					Vec2r(current->vertexA()->point2D()[0],current->vertexA()->point2D()[1]),
+					Vec2r(current->vertexB()->point2D()[0],current->vertexB()->point2D()[1])))
+        return false;
+      current = current->nextEdge();
+    }while((current != 0) && (current != _FEdgeA));
+    
+    return true;
+  }
+
+  /* Information access interface */
+  
+  //inline Nature::EdgeNature viewedge_nature() const {return getNature();}
+  //float viewedge_length() const ;
+  /*! Returns the 2D length of the Viewedge. */
+  real getLength2D() const;
+  //inline Material material() const {return _FEdgeA->vertexA()->shape()->material();}
+  inline int qi() const {return _qi;}
+  inline occluder_container::const_iterator occluders_begin() const {return _Occluders.begin();}
+  inline occluder_container::const_iterator occluders_end() const {return _Occluders.end();}
+  inline int occluders_size() const {return _Occluders.size();}
+  inline bool occluders_empty() const {return _Occluders.empty();}
+  inline const Polygon3r& occludee() const {return (_FEdgeA->aFace());}
+  inline const SShape * occluded_shape() const ;
+  inline const bool occludee_empty() const {if(_aShape == 0) return true; return false;}
+  //inline real z_discontinuity(int iCombination = 0) const ;
+  inline Id shape_id() const {return _FEdgeA->vertexA()->shape()->getId();}
+  inline const SShape * shape() const {return _FEdgeA->vertexA()->shape();}
+  inline float shape_importance() const {return _FEdgeA->shape_importance();} 
+
+  /* iterators access */
+  // view edge iterator
+  edge_iterator ViewEdge_iterator();
+  const_edge_iterator ViewEdge_iterator() const;
+  // feature edge iterator
+  fedge_iterator fedge_iterator_begin();
+  const_fedge_iterator fedge_iterator_begin() const;
+  fedge_iterator fedge_iterator_last();
+  const_fedge_iterator fedge_iterator_last() const;
+  fedge_iterator fedge_iterator_end();
+  const_fedge_iterator fedge_iterator_end() const;
+  // embedding vertex iterator
+  const_vertex_iterator vertices_begin() const;
+  vertex_iterator vertices_begin();
+  const_vertex_iterator vertices_last() const;
+  vertex_iterator vertices_last();
+  const_vertex_iterator vertices_end() const;
+  vertex_iterator vertices_end();
+
+  // Iterator access (Interface1D)
+  /*! Returns an Interface0DIterator to iterate over
+   *  the SVertex constituing the embedding of this ViewEdge.
+   *  The returned Interface0DIterator points to the first
+   *  SVertex of the ViewEdge.
+   */
+  virtual Interface0DIterator verticesBegin();
+  /*! Returns an Interface0DIterator to iterate over
+   *  the SVertex constituing the embedding of this ViewEdge.
+   *  The returned Interface0DIterator points after the last
+   *  SVertex of the ViewEdge.
+   */
+  virtual Interface0DIterator verticesEnd();
+
+  /*! Returns an Interface0DIterator to iterate over
+   *  the points of this ViewEdge at a given resolution.
+   *  The returned Interface0DIterator points on the first
+   *  Point of the ViewEdge.
+   *  \param t
+   *    the sampling value.
+   */
+  virtual Interface0DIterator pointsBegin(float t=0.f);
+  /*! Returns an Interface0DIterator to iterate over
+   *  the points of this ViewEdge at a given resolution.
+   *  The returned Interface0DIterator points after the last
+   *  Point of the ViewEdge.
+   *  \param t
+   *    the sampling value.
+   */
+  virtual Interface0DIterator pointsEnd(float t=0.f);
+};
+
+  
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewShape          */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/*! Class gathering the elements of the ViewMap (ViewVertex, ViewEdge)
+ *  that are issued from the same input shape.
+ */
+class LIB_VIEW_MAP_EXPORT ViewShape
+{
+private:
+  vector<ViewVertex*> _Vertices;
+  vector<ViewEdge*> _Edges;
+  SShape * _SShape;
+  
+
+public:
+  /*! A field that can be used by the user to store any data.
+   *  This field must be reseted afterwards using ResetUserData().
+   */
+  void* userdata;
+  /*! Default constructor.*/
+  inline ViewShape() { userdata = 0; _SShape = 0;}
+  /*! Builds a ViewShape from a SShape. */
+  inline ViewShape(SShape *iSShape) {userdata = 0; _SShape = iSShape;}//_SShape->setViewShape(this);}
+  /*! Copy constructor. */
+  inline ViewShape(ViewShape& iBrother)
+  {
+    userdata = 0;
+    vector<ViewVertex*>::iterator vv,vvend;
+    vector<ViewEdge*>::iterator ve, veend;
+
+    _SShape = iBrother._SShape;
+
+    vector<ViewVertex*>& vvertices = iBrother.vertices();
+    // duplicate vertices
+    for(vv=vvertices.begin(), vvend=vvertices.end();
+    vv!=vvend;
+    vv++)
+    {
+      ViewVertex * newVertex = (*vv)->duplicate();
+      AddVertex(newVertex);
+    }
+
+    vector<ViewEdge*>& vvedges = iBrother.edges();
+    // duplicate edges
+    for(ve=vvedges.begin(), veend=vvedges.end();
+    ve!=veend;
+    ve++)
+    {
+      ViewEdge * newEdge = (*ve)->duplicate();
+      AddEdge(newEdge); // here the shape is set as the edge's shape
+    }
+
+    //-------------------------
+    // remap edges in vertices:
+    //-------------------------
+    for(vv=_Vertices.begin(), vvend=_Vertices.end();
+    vv!=vvend;
+    vv++)
+    {
+      switch((*vv)->getNature())
+      {  
+      case Nature::T_VERTEX:
+        {
+          TVertex *v = (TVertex*)(*vv);
+          ViewEdge *veFrontA = (ViewEdge*)(v)->frontEdgeA().first->userdata;
+          ViewEdge *veFrontB = (ViewEdge*)(v)->frontEdgeB().first->userdata;
+          ViewEdge *veBackA = (ViewEdge*)(v)->backEdgeA().first->userdata;
+          ViewEdge *veBackB = (ViewEdge*)(v)->backEdgeB().first->userdata;
+
+          v->setFrontEdgeA(veFrontA, v->frontEdgeA().second);
+          v->setFrontEdgeB(veFrontB, v->frontEdgeB().second);
+          v->setBackEdgeA(veBackA, v->backEdgeA().second);
+          v->setBackEdgeB(veBackB, v->backEdgeB().second);
+        }
+        break;
+      case Nature::NON_T_VERTEX:
+        {
+          NonTVertex * v = (NonTVertex*)(*vv);
+          vector<ViewVertex::directedViewEdge>& vedges = (v)->viewedges();
+          vector<ViewVertex::directedViewEdge> newEdges;
+          for(vector<ViewVertex::directedViewEdge>::iterator ve=vedges.begin(), veend=vedges.end();
+          ve!=veend;
+          ve++)
+          {
+            ViewEdge *current = (ViewEdge*)((ve)->first)->userdata;
+            newEdges.push_back(ViewVertex::directedViewEdge(current, ve->second));
+          }
+          (v)->setViewEdges(newEdges);
+        }
+        break;
+      default:
+	;
+      }
+    }
+    
+    //-------------------------------------
+    // remap vertices in edges:
+    //-------------------------------------
+    for(ve=_Edges.begin(),veend=_Edges.end();
+        ve!=veend;
+        ve++)
+      {
+        (*ve)->setA((ViewVertex*)((*ve)->A()->userdata));
+        (*ve)->setB((ViewVertex*)((*ve)->B()->userdata));
+        //---------------------------------------
+        // Update all embedded FEdges
+        //---------------------------------------
+        (*ve)->UpdateFEdges();
+      }
+    
+    
+    // reset all brothers userdata to NULL:
+    //-------------------------------------
+    //---------
+    // vertices
+    //---------
+    for(vv=vvertices.begin(),vvend=vvertices.end();
+        vv!=vvend;
+        vv++)
+      {
+        (*vv)->userdata = NULL;
+      }
+
+    //------
+    // edges
+    //------
+    for(ve=vvedges.begin(),veend=vvedges.end();
+        ve!=veend;
+        ve++)
+      {
+        (*ve)->userdata = NULL;
+      }  
+  }
+
+  /*! Cloning method. */
+  virtual ViewShape * duplicate()
+  {
+    ViewShape *clone = new ViewShape(*this);
+    return clone;
+  }
+
+  /*! Destructor. */
+  virtual ~ViewShape();
+
+  /* splits a view edge into several view edges. 
+   *    fe
+   *      The FEdge that gets splitted
+   *    iViewVertices
+   *      The view vertices corresponding to the different intersections for the edge fe.
+   *      This list need to be sorted such as the first view vertex is the 
+   *      farther away from fe->vertexA.
+   *    ioNewEdges
+   *      The feature edges that are newly created (the initial edges are not 
+   *      included) are added to this list.
+   *    ioNewViewEdges
+   *      The view edges that are newly created (the initial edges are not 
+   *      included) are added to this list.  
+   */
+  inline void SplitEdge(FEdge *fe, 
+                        const vector<TVertex*>& iViewVertices, 
+                        vector<FEdge*>& ioNewEdges,
+                        vector<ViewEdge*>& ioNewViewEdges);
+  /* accessors */
+  /*! Returns the SShape on top of which this ViewShape is built. */
+  inline  SShape * sshape()  {return _SShape;}
+    /*! Returns the SShape on top of which this ViewShape is built. */
+  inline  const SShape * sshape() const {return _SShape;}
+  /*! Returns the list of ViewVertex contained in this ViewShape. */
+  inline  vector<ViewVertex*>& vertices() {return _Vertices;}
+  /*! Returns the list of ViewEdge contained in this ViewShape. */
+  inline  vector<ViewEdge*>& edges() {return _Edges;}
+  /*! Returns the ViewShape id. */
+  inline  Id getId() const {return _SShape->getId();}
+
+  /* modifiers */
+  /*! Sets the SShape on top of which the ViewShape is built. */
+  inline void setSShape(SShape* iSShape) {_SShape = iSShape;}
+  /*! Sets the list of ViewVertex contained in this ViewShape. */
+  inline void setVertices(const vector<ViewVertex*>& iVertices) {_Vertices = iVertices;}
+  /*! Sets the list of ViewEdge contained in this ViewShape. */
+  inline void setEdges(const vector<ViewEdge*>& iEdges) {_Edges = iEdges;}
+  /*! Adds a ViewVertex to the list. */
+  inline void AddVertex(ViewVertex *iVertex) 
+  {
+    _Vertices.push_back(iVertex);
+    //_SShape->AddNewVertex(iVertex->svertex());
+  }
+  /*! Adds a ViewEdge to the list */
+  inline void AddEdge(ViewEdge *iEdge) 
+  {
+    _Edges.push_back(iEdge);
+    iEdge->setShape(this);
+    //_SShape->AddNewEdge(iEdge->fedge());
+  }
+
+  /* removes the view edge iViewEdge in the 
+   *  View Shape and the associated FEdge chain entry
+   *  in the underlying SShape 
+   */
+  void RemoveEdge(ViewEdge * iViewEdge);
+
+  /* removes the view vertex iViewVertex in the 
+   *  View Shape.
+   */
+  void RemoveVertex(ViewVertex * iViewVertex);
+};
+
+
+
+/*
+  
+  #############################################
+  #############################################
+  #############################################
+  ######                                 ######
+  ######   I M P L E M E N T A T I O N   ######
+  ######                                 ######
+  #############################################
+  #############################################
+  #############################################
+  
+*/
+/* for inline functions */
+
+void ViewShape::SplitEdge(FEdge *fe, 
+                        const vector<TVertex*>& iViewVertices, 
+                        vector<FEdge*>& ioNewEdges,
+                        vector<ViewEdge*>& ioNewViewEdges)
+{ 
+    ViewEdge *vEdge = fe->viewedge();
+
+    
+    // We first need to sort the view vertices from farther to closer to fe->vertexA
+    
+    SVertex *sv, *sv2; 
+    ViewVertex *vva, *vvb;
+    vector<TVertex*>::const_iterator vv, vvend;
+    for(vv=iViewVertices.begin(), vvend = iViewVertices.end();
+    vv!=vvend;
+    vv++)
+    {
+      // Add the viewvertices to the ViewShape
+      AddVertex((*vv));
+      
+      // retrieve the correct SVertex from the view vertex
+      //--------------------------------------------------
+      sv = (*vv)->frontSVertex();
+      sv2 = (*vv)->backSVertex();
+
+      if(sv->shape() != sv2->shape())
+      {
+        if(sv->shape() != _SShape)
+          sv = sv2;
+      }
+      else
+      {
+        // if the shape is the same we can safely differ 
+        // the two vertices using their ids:
+        if(sv->getId() != fe->vertexA()->getId())
+          sv = sv2;
+      }
+      
+      vva = vEdge->A();
+      vvb = vEdge->B();
+      
+      // We split Fedge AB into AA' and A'B. A' and A'B are created.
+      // AB becomes (address speaking) AA'. B is updated.
+      //--------------------------------------------------
+      SShape * shape = fe->shape();
+      
+      // a new edge, A'B is created.
+      FEdge *newEdge = shape->SplitEdgeIn2(fe, sv);
+
+      ioNewEdges.push_back(newEdge);
+      ViewEdge *newVEdge;
+
+      if((vva == 0) || (vvb == 0)) // that means we're dealing with a closed viewedge (loop)
+      {
+        // remove the chain that was starting by the fedge A of vEdge (which is different from fe !!!!)
+        shape->RemoveEdgeFromChain(vEdge->fedgeA());
+        // we set 
+        vEdge->setA(*vv);
+        vEdge->setB(*vv);
+        vEdge->setFEdgeA(newEdge);
+        //FEdge *previousEdge = newEdge->previousEdge();  
+        vEdge->setFEdgeB(fe);
+        newVEdge = vEdge;
+        vEdge->fedgeA()->setViewEdge(newVEdge);
+      }
+      else
+      {
+        
+        // while we create the view edge, it updates the "ViewEdge" pointer 
+        // of every underlying FEdges to this.
+        newVEdge = new ViewEdge((*vv),vvb);//, newEdge, vEdge->fedgeB());
+        newVEdge->setNature((fe)->getNature());
+        newVEdge->setFEdgeA(newEdge);
+        //newVEdge->setFEdgeB(fe);
+        // If our original viewedge is made of one FEdge, 
+        // then 
+        if((vEdge->fedgeA() == vEdge->fedgeB()) || (fe == vEdge->fedgeB()))
+          newVEdge->setFEdgeB(newEdge);
+        else
+          newVEdge->setFEdgeB(vEdge->fedgeB()); //MODIF
+
+        Id * newId = vEdge->splittingId();
+        if(newId == 0){
+          newId = new Id(vEdge->getId());
+          vEdge->setSplittingId(newId);
+        }
+        newId->setSecond(newId->getSecond()+1);
+        newVEdge->setId(*newId);
+        newVEdge->setSplittingId(newId);
+        //        Id id(vEdge->getId().getFirst(), vEdge->getId().getSecond()+1);
+        //        newVEdge->setId(vEdge->getId());
+        //        vEdge->setId(id);
+        
+        AddEdge(newVEdge); // here this shape is set as the edge's shape
+      
+        // add new edge to the list of new edges passed as argument:
+        ioNewViewEdges.push_back(newVEdge);
+
+      
+        
+        if(0 != vvb) 
+          vvb->Replace((vEdge), newVEdge);
+
+        // we split the view edge:
+        vEdge->setB((*vv));
+        vEdge->setFEdgeB(fe); //MODIF
+      
+        // Update fedges so that they point to the new viewedge:
+        newVEdge->UpdateFEdges();
+
+      }
+      // check whether this vertex is a front vertex or a back
+      // one
+      
+      if(sv == (*vv)->frontSVertex())
+      { 
+        // -- View Vertex A' --
+        (*vv)->setFrontEdgeA(vEdge, true);
+        (*vv)->setFrontEdgeB(newVEdge, false);
+      }
+      else
+      {
+        // -- View Vertex A' --
+        (*vv)->setBackEdgeA(vEdge, true);
+        (*vv)->setBackEdgeB(newVEdge, false);
+      }
+    }
+} 
+    
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+                  
+// inline Vec3r ViewEdge::orientation2d(int iCombination) const
+// {
+//  return edge_orientation2d_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline Vec3r  ViewEdge::orientation3d(int iCombination) const
+// {
+//  return edge_orientation3d_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline real ViewEdge::z_discontinuity(int iCombination) const 
+// {
+//   return z_discontinuity_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline float ViewEdge::local_average_depth(int iCombination ) const
+// {
+//   return local_average_depth_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline float ViewEdge::local_depth_variance(int iCombination) const 
+// {
+//   return local_depth_variance_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline real ViewEdge::local_average_density(float sigma, int iCombination) const 
+// {
+//   return density_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+inline const SShape * ViewEdge::occluded_shape() const 
+{
+  if(0 == _aShape)
+    return 0;
+  return _aShape->sshape();
+}  
+
+// inline Vec3r ViewEdge::curvature2d_as_vector(int iCombination) const 
+// {
+//   return curvature2d_as_vector_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+// inline real ViewEdge::curvature2d_as_angle(int iCombination) const 
+// {
+//   return curvature2d_as_angle_edge_function<ViewEdge>(*this, iCombination);
+// }
+
+
+#endif // VIEWMAP_H
diff --git a/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h b/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
new file mode 100755
index 00000000000..bb2d916f2df
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h
@@ -0,0 +1,691 @@
+//
+//  Filename         : ViewMapAdvancedIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the various elements of the ViewMap
+//                     These iterators can't be exported to python.
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAPADVANCEDITERATORS_H
+# define VIEWMAPADVANCEDITERATORS_H
+
+#include "ViewMap.h"
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewMap            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewVertex         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+namespace ViewVertexInternal{
+
+  class edge_const_traits : public Const_traits< ::ViewVertex::directedViewEdge> {
+  public:
+     typedef vector< ::ViewVertex::directedViewEdge> edges_container;
+    typedef edges_container::const_iterator edges_container_iterator ;
+    typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container;
+    typedef edge_pointers_container::const_iterator edge_pointers_container_iterator ;
+  }; 
+  class edge_nonconst_traits : public Nonconst_traits< ::ViewVertex::directedViewEdge> {
+  public:
+    typedef vector< ::ViewVertex::directedViewEdge> edges_container;
+    typedef edges_container::iterator edges_container_iterator ;
+    typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container;
+    typedef edge_pointers_container::iterator edge_pointers_container_iterator ;
+  };
+  
+template<class Traits>
+  class edge_iterator_base : public IteratorBase<Traits,InputIteratorTag_Traits>
+  {
+  public:
+    typedef typename Traits::value_type                       value_type;
+    typedef typename Traits::difference_type                  difference_type;
+    typedef typename Traits::pointer                          pointer;
+    typedef typename Traits::reference                        reference;
+    typedef edge_iterator_base<Traits>  Self;
+    typedef typename Traits::edges_container_iterator  edges_container_iterator;
+    typedef typename Traits::edge_pointers_container_iterator  edge_pointers_container_iterator;
+    typedef edge_iterator_base<edge_nonconst_traits> iterator;
+    typedef edge_iterator_base<edge_const_traits> const_iterator;
+  public:
+    friend class ViewVertex;
+    friend class TVertex;
+    friend class NonTVertex;
+    friend class ViewEdge;
+    friend class edge_iterator;
+  protected:
+    Nature::VertexNature _Nature; // the nature of the underlying vertex
+    // T vertex attributes
+    edge_pointers_container_iterator _tbegin;
+    edge_pointers_container_iterator _tend;
+    edge_pointers_container_iterator _tvertex_iter;
+
+    //    mutable value_type _tvertex_iter;
+    //    value_type _feA;
+    //    value_type _feB;
+    //    value_type _beA;
+    //    value_type _beB;
+
+    // Non TVertex attributes
+    edges_container_iterator _begin;
+    edges_container_iterator _end;
+    edges_container_iterator _nontvertex_iter;
+
+    typedef IteratorBase<Traits,InputIteratorTag_Traits> parent_class;
+
+  public:
+    inline edge_iterator_base() : parent_class() {}
+    inline edge_iterator_base(Nature::VertexNature iNature)
+      : parent_class()
+    {_Nature = iNature;}
+    edge_iterator_base(const edge_iterator_base<edge_nonconst_traits>& iBrother)
+    : parent_class(iBrother)
+    {
+      _Nature = iBrother._Nature;
+      if(_Nature & Nature::T_VERTEX)
+      {
+        //        _feA = iBrother._feA;
+        //        _feB = iBrother._feB;
+        //        _beA = iBrother._beA;
+        //        _beB = iBrother._beB;
+        //        _tvertex_iter = iBrother._tvertex_iter;
+        _tbegin = iBrother._tbegin;
+        _tend = iBrother._tend;
+        _tvertex_iter = iBrother._tvertex_iter;
+      }
+      else
+      {
+        _begin = iBrother._begin;
+        _end = iBrother._end;
+        _nontvertex_iter = iBrother._nontvertex_iter;
+      }
+    }
+    edge_iterator_base(const edge_iterator_base<edge_const_traits>& iBrother)
+      : parent_class(iBrother)
+    {
+      _Nature = iBrother._Nature;
+      if(_Nature & Nature::T_VERTEX)
+      {
+        //        _feA = iBrother._feA;
+        //        _feB = iBrother._feB;
+        //        _beA = iBrother._beA;
+        //        _beB = iBrother._beB;
+        //        _tvertex_iter = iBrother._tvertex_iter;
+        _tbegin = iBrother._tbegin;
+        _tend = iBrother._tend;
+        _tvertex_iter = iBrother._tvertex_iter;
+      }
+      else
+      {
+        _begin = iBrother._begin;
+        _end = iBrother._end;
+        _nontvertex_iter = iBrother._nontvertex_iter;
+      }
+    }
+    virtual ~edge_iterator_base() {}
+  //protected://FIXME
+  public:
+    //    inline edge_iterator_base(value_type ifeA, 
+    //                         value_type ifeB, 
+    //                         value_type ibeA, 
+    //                         value_type ibeB,
+    //                         value_type iter)
+    //      : parent_class()
+    //    {
+    //      _Nature = Nature::T_VERTEX;
+    //      _feA = ifeA;
+    //      _feB = ifeB;
+    //      _beA = ibeA;
+    //      _beB = ibeB;
+    //      _tvertex_iter = iter;
+    //    }
+    inline edge_iterator_base(edge_pointers_container_iterator begin, 
+                         edge_pointers_container_iterator end,
+                         edge_pointers_container_iterator iter)
+                         : parent_class()
+    {
+      _Nature = Nature::T_VERTEX;
+      _tbegin = begin;
+      _tend = end;
+      _tvertex_iter = iter;
+    } 
+    inline edge_iterator_base(edges_container_iterator begin, 
+                         edges_container_iterator end,
+                         edges_container_iterator iter)
+                         : parent_class()
+    {
+      _Nature = Nature::NON_T_VERTEX;
+      _begin = begin;
+      _end = end;
+      _nontvertex_iter = iter;
+    } 
+
+  public:
+
+    
+    virtual bool begin() const 
+    {
+      if(_Nature & Nature::T_VERTEX)
+        return (_tvertex_iter == _tbegin);
+        //return (_tvertex_iter == _feA);
+      else
+        return (_nontvertex_iter == _begin);
+    }
+    virtual bool end() const 
+    {
+      if(_Nature & Nature::T_VERTEX)
+        //return (_tvertex_iter.first == 0);
+        return (_tvertex_iter == _tend);
+      else
+        return (_nontvertex_iter == _end);
+    }
+
+    // operators
+    virtual Self& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    virtual Self operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    } 
+  
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      if(_Nature & Nature::T_VERTEX)
+        return (_tvertex_iter != b._tvertex_iter);
+      else
+        return (_nontvertex_iter != b._nontvertex_iter);
+    }
+    
+    virtual bool operator==(const Self& b) const
+    {return !(*this != b);}
+    
+    // dereferencing
+    virtual reference operator*() const
+    {
+      if(_Nature & Nature::T_VERTEX)
+        //return _tvertex_iter;
+        return **_tvertex_iter;
+      else
+        return (*_nontvertex_iter);
+    }
+    virtual pointer operator->() const { return &(operator*());}
+
+  protected:
+    inline void increment()
+    {
+      if(_Nature & Nature::T_VERTEX)
+        {
+        value_type tmp = (**_tvertex_iter);
+        ++_tvertex_iter;
+        value_type tmp2 = (**_tvertex_iter);
+        if(tmp2.first == tmp.first)
+          ++_tvertex_iter;
+        //          // Hack to deal with cusp. the result of a cusp
+        //          // is a TVertex having two identical viewedges.
+        //          // In order to iterate properly, we chose to 
+        //          // to skip these last ones.
+        //          if(_feB.first == _beA.first)
+        //          {
+        //            if(_feA.first == _beB.first)
+        //            {
+        //              _tvertex_iter.first = 0;
+        //              return;
+        //            }
+        //            
+        //            if(_tvertex_iter.first == _feA.first)
+        //              _tvertex_iter.first = _beB.first;
+        //            else if(_tvertex_iter.first == _beB.first)
+        //              _tvertex_iter.first = 0;
+        //            else
+        //              _tvertex_iter.first = _feA.first;
+        //            return;
+        //          }
+        //          if(_feA.first == _beB.first)
+        //          {
+        //            if(_feB.first == _beA.first)
+        //            {
+        //              _tvertex_iter.first = 0;
+        //              return;
+        //            }
+        //            
+        //            if(_tvertex_iter.first == _feB.first)
+        //              _tvertex_iter.first = _beA.first;
+        //            else if(_tvertex_iter.first == _beA.first)
+        //              _tvertex_iter.first = 0;
+        //            else
+        //              _tvertex_iter.first = _feB.first;
+        //            return;
+        //          }
+        //          // End of hack
+        //
+        //          if(_tvertex_iter.first == _feA.first){
+        //            // we return bea or beb 
+        //            
+        //
+        //            // choose one of them
+        //            
+        //              _tvertex_iter.first = _feB.first;
+        //              return;
+        //            }
+        //          if(_tvertex_iter.first == _feB.first)
+        //            {
+        //              _tvertex_iter.first = _beA.first;
+        //              return;
+        //            }
+        //          if(_tvertex_iter.first == _beA.first)
+        //            {
+        //              _tvertex_iter.first = _beB.first;
+        //              return;
+        //            }
+        //          if(_tvertex_iter.first == _beB.first)
+        //            {
+        //              _tvertex_iter.first = 0;
+        //              return;
+        //            }
+        }
+      else
+        ++_nontvertex_iter;
+    }
+  };
+
+  }
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+namespace ViewEdgeInternal {
+
+  /*!----------------------*/
+  /*! Iterators definition */
+  /*!----------------------*/
+  template<class Traits>
+  class edge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
+  {
+  public:
+    typedef typename Traits::value_type                       value_type;
+    typedef typename Traits::difference_type                  difference_type;
+    typedef typename Traits::pointer                          pointer;
+    typedef typename Traits::reference                        reference;
+    typedef edge_iterator_base<Traits>  Self;
+  public:
+    mutable value_type _ViewEdge;
+    //friend class edge_iterator_base<Nonconst_traits<ViewEdge*> >;
+    //friend class edge_iterator_base<Const_traits<ViewEdge*> >;
+    value_type _first;
+    bool _orientation;
+    typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
+
+  public:
+    friend class ViewEdge;
+    inline edge_iterator_base()
+      : parent_class()
+    {_orientation=true;_first=0;}
+
+    inline edge_iterator_base(const edge_iterator_base<Nonconst_traits< ::ViewEdge*> >& iBrother)
+      : parent_class()
+    {
+      _ViewEdge = iBrother._ViewEdge;
+      _first = iBrother._first;
+      _orientation = iBrother._orientation;
+    }
+
+    inline edge_iterator_base(const edge_iterator_base<Const_traits< ::ViewEdge*> >& iBrother)
+      : parent_class()
+    {
+      _ViewEdge = iBrother._ViewEdge;
+      _first = iBrother._first;
+      _orientation = iBrother._orientation;
+    }
+
+  //protected://FIXME
+  public:
+    inline edge_iterator_base(value_type iEdge, bool orientation = true)
+      : parent_class()
+    {
+      _ViewEdge = iEdge;
+      _first = iEdge;
+      _orientation = orientation;
+    }
+  
+    
+  public:
+    virtual Self* clone() const 
+    {
+      return new edge_iterator_base(*this);
+    }
+    virtual ~edge_iterator_base() {}
+
+  public:
+    
+    virtual bool orientation() {return _orientation;}
+    virtual void set_edge(value_type iVE) {_ViewEdge=iVE;}
+    virtual void set_orientation(bool iOrientation) {_orientation = iOrientation;}
+    virtual void change_orientation() {_orientation = !_orientation;}
+    
+    // operators
+    inline Self& operator++()  // operator corresponding to ++i
+    { 
+      //++_ViewEdge->getTimeStamp();
+      increment();
+      return *this;
+    }
+    inline Self operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      //++_ViewEdge->getTimeStamp();
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    }
+    inline Self& operator--()  // operator corresponding to ++i
+    { 
+      //++_ViewEdge->getTimeStamp();
+      decrement();
+      return *this;
+    }
+    inline Self operator--(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      //++_ViewEdge->getTimeStamp();
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      decrement();                    // dans un temporaire. 
+      return tmp;
+    }
+
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      return (_ViewEdge != b._ViewEdge);
+    }
+    virtual bool operator==(const Self& b) const
+    {
+      return !(*this != b);
+    }
+    
+    // dereferencing
+    virtual reference operator*() const  {return (_ViewEdge);}
+    virtual pointer operator->() const { return &(operator*());}
+    
+  public:
+    virtual bool begin() const {return _ViewEdge==_first ? true : false;}
+    virtual bool end() const {return _ViewEdge==0 ? true : false;}
+
+  protected:
+    virtual void increment() {}
+    virtual void decrement() {}
+  };
+  
+  template<class Traits>
+  class fedge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
+  {
+  public:
+    typedef typename Traits::value_type                       value_type;
+    typedef typename Traits::difference_type                  difference_type;
+    typedef typename Traits::pointer                          pointer;
+    typedef typename Traits::reference                        reference;
+    typedef fedge_iterator_base<Traits>  Self;
+  public:
+    typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
+    mutable value_type _FEdge;
+    value_type _first;
+    value_type _FEdgeB; // last fedge of the view edge
+ 
+  public:
+    friend class ::ViewEdge;
+    friend class fedge_iterator;
+    inline fedge_iterator_base()
+      : parent_class()
+    {}
+    inline fedge_iterator_base(const fedge_iterator_base<Nonconst_traits<FEdge*> >& iBrother)
+      : parent_class()
+    {
+      _FEdge = iBrother._FEdge;
+      _first = iBrother._first;
+      _FEdgeB = iBrother._FEdgeB;
+    }
+    inline fedge_iterator_base(const fedge_iterator_base<Const_traits<FEdge*> >& iBrother)
+      : parent_class()
+    {
+      _FEdge = iBrother._FEdge;
+      _first = iBrother._first;
+      _FEdgeB = iBrother._FEdgeB;
+    }
+  //protected://FIXME
+    public:
+    inline fedge_iterator_base(value_type iEdge, value_type iFEdgeB)
+      : parent_class()
+    {
+      _FEdge = iEdge;
+      _first = iEdge;
+      _FEdgeB = iFEdgeB;
+    }
+    
+  public:
+    virtual ~fedge_iterator_base() {}
+    // operators
+    inline Self& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    inline Self operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    }
+    inline Self& operator--()  // operator corresponding to ++i
+    { 
+      decrement();
+      return *this;
+    }
+    inline Self operator--(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      decrement();                    // dans un temporaire. 
+      return tmp;
+    }
+
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      return (_FEdge != b._FEdge);
+    }
+    virtual bool operator==(const Self& b) const
+    {
+      return !(*this != b);
+    }
+    
+    // dereferencing
+    virtual reference operator*() const  {return (_FEdge);}
+    virtual pointer operator->() const { return &(operator*());}
+
+
+  public:
+    virtual bool begin() const {return _FEdge==_first ? true : false;}
+    virtual bool end() const {return _FEdge==0 ? true : false;}
+  protected:
+    virtual void increment() 
+    {
+      _FEdge = _FEdge->nextEdge(); // we don't change or
+    }
+    
+    virtual void decrement() 
+    {
+      if(0 == _FEdge)
+	{
+	  _FEdge = _FEdgeB;
+	  return;
+	}
+      _FEdge = _FEdge->previousEdge(); // we don't change or
+    }
+  };
+  
+  template<class Traits>
+  class vertex_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
+  {
+  public:
+    typedef typename Traits::value_type                       value_type;
+    typedef typename Traits::difference_type                  difference_type;
+    typedef typename Traits::pointer                          pointer;
+    typedef typename Traits::reference                        reference;
+    typedef vertex_iterator_base<Traits>  Self;
+  protected:
+    typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
+  public:
+    mutable value_type _SVertex;
+    FEdge *_NextFEdge;
+    FEdge *_PreviousFEdge;
+  public:
+    friend class ViewEdge;
+    friend class vertex_iterator;
+    inline vertex_iterator_base()
+      : parent_class()
+    {}
+    inline vertex_iterator_base(const vertex_iterator_base<Const_traits<SVertex*> >& iBrother)
+      : parent_class()
+    {
+      _SVertex = iBrother._SVertex;
+      _NextFEdge = iBrother._NextFEdge;
+      _PreviousFEdge = iBrother._PreviousFEdge;
+    }
+    inline vertex_iterator_base(const vertex_iterator_base<Nonconst_traits<SVertex*> >& iBrother)
+      : parent_class()
+    {
+      _SVertex = iBrother._SVertex;
+      _NextFEdge = iBrother._NextFEdge;
+      _PreviousFEdge = iBrother._PreviousFEdge;
+    }
+    
+  //protected://FIXME
+  public:
+   
+    inline vertex_iterator_base(value_type iVertex, FEdge *iPreviousFEdge, FEdge *iNextFEdge)
+      : parent_class()
+    {
+      _SVertex = iVertex;
+      _NextFEdge = iNextFEdge;
+      _PreviousFEdge = iPreviousFEdge;
+    }
+    
+  public:
+    virtual ~vertex_iterator_base() {}
+
+    virtual bool begin() const {return _PreviousFEdge==0? true : false;}
+    virtual bool end() const {return _SVertex==0 ? true : false;}
+
+    // operators
+    inline Self& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    inline Self operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    }
+    inline Self& operator--()  // operator corresponding to ++i
+    { 
+      decrement();
+      return *this;
+    }
+    inline Self operator--(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      decrement();                    // dans un temporaire. 
+      return tmp;
+    }
+
+    // comparibility
+    virtual bool operator!=(const Self& b) const
+    {
+      return (_SVertex != b._SVertex);
+    }
+    virtual bool operator==(const Self& b) const
+    {
+      return !(*this != b);
+    }
+    
+    // dereferencing
+    virtual reference operator*() const   {return (_SVertex);}
+    virtual pointer operator->() const { return &(operator*());}
+    
+  protected:
+    virtual void increment() 
+    {
+      if(0 == _NextFEdge)
+	{
+	  _SVertex = 0;
+	  return;
+	}
+
+      _SVertex = _NextFEdge->vertexB();
+      _PreviousFEdge = _NextFEdge;
+      _NextFEdge = _NextFEdge->nextEdge();
+       
+    }
+    virtual void decrement() 
+    {
+      //      if(0 == _SVertex)
+      //      {
+      //        _SVertex = _PreviousFEdge->vertexB();
+      //        return;
+      //      }
+      if(0 == _PreviousFEdge)
+	{
+	  _SVertex = 0;
+	  return;
+	}
+      _SVertex = _PreviousFEdge->vertexA();
+      _NextFEdge = _PreviousFEdge;
+      _PreviousFEdge = _PreviousFEdge->previousEdge();
+    }
+  };
+
+  
+} // end of namespace ViewEdgeInternal
+
+#endif // VIEWMAPADVANCEDITERATORS_H
diff --git a/source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp b/source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
new file mode 100755
index 00000000000..89e91e4f2c8
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
@@ -0,0 +1,1027 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <algorithm>
+#include "ViewMapBuilder.h"
+
+using namespace std;
+
+ViewMap* ViewMapBuilder::BuildViewMap(WingedEdge& we, visibility_algo iAlgo, real epsilon) {
+  _ViewMap = new ViewMap;
+  _currentId = 1;
+  _currentFId = 0;
+  _currentSVertexId = 0;
+  
+  // Builds initial view edges
+  computeInitialViewEdges(we);
+  
+  // Detects cusps
+  computeCusps(_ViewMap); 
+  
+  // Compute intersections
+  ComputeIntersections(_ViewMap, sweep_line, epsilon);
+  
+  // Compute visibility
+  ComputeEdgesVisibility(_ViewMap, iAlgo, _Grid, epsilon);
+  
+  return _ViewMap;
+}
+
+void ViewMapBuilder::computeInitialViewEdges(WingedEdge& we)
+{
+  vector<WShape*> wshapes = we.getWShapes();
+  SShape* psShape;
+
+  for (vector<WShape*>::const_iterator it = wshapes.begin();
+       it != wshapes.end();
+       it++) {
+    // create the embedding
+    psShape = new SShape;
+    psShape->setId((*it)->GetId());
+    psShape->setMaterials((*it)->materials()); // FIXME
+
+    // create the view shape
+    ViewShape * vshape = new ViewShape(psShape);
+    // add this view shape to the view map:
+    _ViewMap->AddViewShape(vshape);
+  
+    _pViewEdgeBuilder->setCurrentViewId(_currentId); // we want to number the view edges in a unique way for the while scene.
+    _pViewEdgeBuilder->setCurrentFId(_currentFId); // we want to number the feature edges in a unique way for the while scene.
+    _pViewEdgeBuilder->setCurrentSVertexId(_currentFId); // we want to number the SVertex in a unique way for the while scene.
+    _pViewEdgeBuilder->BuildViewEdges(dynamic_cast<WXShape*>(*it), vshape, 
+				      _ViewMap->ViewEdges(), 
+				      _ViewMap->ViewVertices(), 
+				      _ViewMap->FEdges(), 
+				      _ViewMap->SVertices());
+  
+    _currentId = _pViewEdgeBuilder->currentViewId()+1;
+    _currentFId = _pViewEdgeBuilder->currentFId()+1;
+    _currentSVertexId = _pViewEdgeBuilder->currentSVertexId()+1;
+
+    psShape->ComputeBBox();
+  }
+}
+
+void ViewMapBuilder::computeCusps(ViewMap *ioViewMap){
+  vector<ViewVertex*> newVVertices;
+  vector<ViewEdge*> newVEdges;
+  ViewMap::viewedges_container& vedges = ioViewMap->ViewEdges();
+  ViewMap::viewedges_container::iterator ve=vedges.begin(), veend=vedges.end();
+  for(;
+  ve!=veend;
+  ++ve){
+    if((!((*ve)->getNature() & Nature::SILHOUETTE)) || (!((*ve)->fedgeA()->isSmooth())))
+      continue;
+    FEdge *fe = (*ve)->fedgeA();
+    FEdge * fefirst = fe;
+    bool first = true;
+    bool positive = true;
+    do{
+      FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+      Vec3r A((fes)->vertexA()->point3d());
+      Vec3r B((fes)->vertexB()->point3d());
+      Vec3r AB(B-A);
+      AB.normalize();
+      Vec3r m((A+B)/2.0);
+      Vec3r crossP(AB^(fes)->normal()); 
+      crossP.normalize();
+      Vec3r viewvector(m-_viewpoint);
+      viewvector.normalize();
+      if(first){
+        if(((crossP)*(viewvector)) > 0)
+          positive = true;
+        else
+          positive = false;
+        first = false;
+      }
+      // If we're in a positive part, we need 
+      // a stronger negative value to change
+      NonTVertex *cusp = 0;
+      if(positive){
+        if(((crossP)*(viewvector)) < -0.1){
+          // state changes
+          positive = false;
+          // creates and insert cusp
+          cusp = dynamic_cast<NonTVertex*>(ioViewMap->InsertViewVertex(fes->vertexA(), newVEdges));
+          if(cusp!=0)
+            cusp->setNature(cusp->getNature()|Nature::CUSP);
+        }
+          
+      }else{
+        // If we're in a negative part, we need 
+        // a stronger negative value to change
+        if(((crossP)*(viewvector)) > 0.1){
+          positive = true;
+          cusp = dynamic_cast<NonTVertex*>(ioViewMap->InsertViewVertex(fes->vertexA(), newVEdges));
+          if(cusp!=0)
+            cusp->setNature(cusp->getNature()|Nature::CUSP);
+        }
+      }
+      fe = fe->nextEdge();
+    }while((fe!=0) && (fe!=fefirst));
+  }
+  for(ve=newVEdges.begin(), veend=newVEdges.end();
+  ve!=veend;
+  ++ve){
+    (*ve)->viewShape()->AddEdge(*ve);
+    vedges.push_back(*ve);
+  }
+}
+void ViewMapBuilder::ComputeEdgesVisibility(ViewMap *ioViewMap, visibility_algo iAlgo,  Grid *iGrid, real epsilon)
+{
+  if((iAlgo == ray_casting ||
+      iAlgo == ray_casting_fast ||
+      iAlgo == ray_casting_very_fast) && (NULL == iGrid))
+  {
+    cerr << "Error: can't cast ray, no grid defined" << endl;
+    return;
+  }
+
+  switch(iAlgo)
+  {
+  case ray_casting:
+    ComputeRayCastingVisibility(ioViewMap, iGrid, epsilon);
+    break;
+  case ray_casting_fast:
+    ComputeFastRayCastingVisibility(ioViewMap, iGrid, epsilon);
+    break;
+  case ray_casting_very_fast:
+    ComputeVeryFastRayCastingVisibility(ioViewMap, iGrid, epsilon);
+    break;
+  default:
+    break;
+  }
+}
+
+static const unsigned gProgressBarMaxSteps = 10;
+static const unsigned gProgressBarMinSize = 2000;
+
+void ViewMapBuilder::ComputeRayCastingVisibility(ViewMap *ioViewMap, Grid* iGrid, real epsilon)
+{
+  vector<ViewEdge*>& vedges = ioViewMap->ViewEdges();
+  bool progressBarDisplay = false;
+  unsigned progressBarStep = 0;
+  unsigned vEdgesSize = vedges.size();
+  unsigned fEdgesSize = ioViewMap->FEdges().size();
+
+  if(_pProgressBar != NULL && fEdgesSize > gProgressBarMinSize) {
+    unsigned progressBarSteps = min(gProgressBarMaxSteps, vEdgesSize);
+    progressBarStep = vEdgesSize / progressBarSteps;
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Computing Ray casting Visibility");
+    _pProgressBar->setTotalSteps(progressBarSteps);
+    _pProgressBar->setProgress(0);
+    progressBarDisplay = true;
+  }
+  
+  unsigned counter = progressBarStep;
+  FEdge * fe, *festart;
+  int nSamples = 0;
+  vector<Polygon3r*> aFaces;
+  Polygon3r *aFace = 0;
+  unsigned tmpQI = 0;
+  unsigned qiClasses[256];
+  unsigned maxIndex, maxCard;
+  unsigned qiMajority;
+  static unsigned timestamp = 1;
+  for(vector<ViewEdge*>::iterator ve=vedges.begin(), veend=vedges.end();
+  ve!=veend;
+  ve++)
+  {
+    festart = (*ve)->fedgeA();
+    fe = (*ve)->fedgeA();
+    qiMajority = 1;
+    do {
+       qiMajority++;
+       fe = fe->nextEdge();
+    } while (fe && fe != festart);
+    qiMajority >>= 1;
+
+    tmpQI = 0;
+    maxIndex = 0;
+    maxCard = 0;
+    nSamples = 0;
+    fe = (*ve)->fedgeA();
+    memset(qiClasses, 0, 256 * sizeof(*qiClasses));
+    set<ViewShape*> occluders;
+    do
+    {
+      if((maxCard < qiMajority)) {
+	tmpQI = ComputeRayCastingVisibility(fe, iGrid, epsilon, occluders, &aFace, timestamp++);
+	
+	if(tmpQI >= 256)
+	  cerr << "Warning: too many occluding levels" << endl;
+
+	if (++qiClasses[tmpQI] > maxCard) {
+	  maxCard = qiClasses[tmpQI];
+	  maxIndex = tmpQI;
+	}
+      }
+      else
+	FindOccludee(fe, iGrid, epsilon, &aFace, timestamp++);
+
+      if(aFace) { 
+	fe->setaFace(*aFace);
+	aFaces.push_back(aFace);
+	fe->setOccludeeEmpty(false);
+      }
+      else
+	fe->setOccludeeEmpty(true);
+
+      ++nSamples;
+      fe = fe->nextEdge();
+    }
+    while((maxCard < qiMajority) && (0!=fe) && (fe!=festart));
+
+    // ViewEdge
+    // qi --
+    (*ve)->setQI(maxIndex);
+    // occluders --
+    for(set<ViewShape*>::iterator o=occluders.begin(), oend=occluders.end();
+    o!=oend;
+    ++o)
+      (*ve)->AddOccluder((*o));
+    // occludee --
+    if(!aFaces.empty())
+    {
+      if(aFaces.size() <= (float)nSamples/2.f)
+      {
+        (*ve)->setaShape(0);
+      }
+      else
+      {
+        vector<Polygon3r*>::iterator p = aFaces.begin();
+        WFace * wface = (WFace*)((*p)->userdata);
+        ViewShape *vshape = ioViewMap->viewShape(wface->GetVertex(0)->shape()->GetId());
+        ++p;
+        (*ve)->setaShape(vshape);
+      }
+    }
+    
+    if(progressBarDisplay) {  
+      counter--;
+      if (counter <= 0) {
+	counter = progressBarStep;
+	_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+      }
+    }   
+    aFaces.clear();
+  }    
+}
+
+void ViewMapBuilder::ComputeFastRayCastingVisibility(ViewMap *ioViewMap, Grid* iGrid, real epsilon)
+{
+  vector<ViewEdge*>& vedges = ioViewMap->ViewEdges();
+  bool progressBarDisplay = false;
+  unsigned progressBarStep = 0;
+  unsigned vEdgesSize = vedges.size();
+  unsigned fEdgesSize = ioViewMap->FEdges().size();
+
+  if(_pProgressBar != NULL && fEdgesSize > gProgressBarMinSize) {
+    unsigned progressBarSteps = min(gProgressBarMaxSteps, vEdgesSize);
+    progressBarStep = vEdgesSize / progressBarSteps;
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Computing Ray casting Visibility");
+    _pProgressBar->setTotalSteps(progressBarSteps);
+    _pProgressBar->setProgress(0);
+    progressBarDisplay = true;
+  }
+
+  unsigned counter = progressBarStep;  
+  FEdge * fe, *festart;
+  unsigned nSamples = 0;
+  vector<Polygon3r*> aFaces;
+  Polygon3r *aFace = 0;
+  unsigned tmpQI = 0;
+  unsigned qiClasses[256];
+  unsigned maxIndex, maxCard;
+  unsigned qiMajority;
+  static unsigned timestamp = 1;
+  bool even_test;
+  for(vector<ViewEdge*>::iterator ve=vedges.begin(), veend=vedges.end();
+  ve!=veend;
+  ve++)
+  {
+    festart = (*ve)->fedgeA();
+    fe = (*ve)->fedgeA();
+    qiMajority = 1;
+    do {
+       qiMajority++;
+       fe = fe->nextEdge();
+    } while (fe && fe != festart);
+    if (qiMajority >= 4)
+      qiMajority >>= 2;
+    else
+      qiMajority = 1;
+
+    set<ViewShape*> occluders;
+
+    even_test = true;
+    maxIndex = 0;
+    maxCard = 0;
+    nSamples = 0;
+    memset(qiClasses, 0, 256 * sizeof(*qiClasses));
+    fe = (*ve)->fedgeA();
+    do
+    {
+      if (even_test)
+      {
+	if((maxCard < qiMajority)) {
+	  tmpQI = ComputeRayCastingVisibility(fe, iGrid, epsilon, occluders, &aFace, timestamp++);
+	  
+	  if(tmpQI >= 256)
+	    cerr << "Warning: too many occluding levels" << endl;
+
+	  if (++qiClasses[tmpQI] > maxCard) {
+	    maxCard = qiClasses[tmpQI];
+	    maxIndex = tmpQI;
+	  }
+	}
+	else
+	  FindOccludee(fe, iGrid, epsilon, &aFace, timestamp++);
+
+        if(aFace)
+        { 
+          fe->setaFace(*aFace);
+          aFaces.push_back(aFace);
+        } 
+        ++nSamples;
+	even_test = false;
+      }
+      else
+	even_test = true;
+      fe = fe->nextEdge();
+    } while ((maxCard < qiMajority) && (0!=fe) && (fe!=festart));
+
+    (*ve)->setQI(maxIndex);
+
+    if(!aFaces.empty())
+    {
+      if(aFaces.size() < nSamples / 2)
+      {
+        (*ve)->setaShape(0);
+      }
+      else
+      {
+        vector<Polygon3r*>::iterator p = aFaces.begin();
+        WFace * wface = (WFace*)((*p)->userdata);
+        ViewShape *vshape = ioViewMap->viewShape(wface->GetVertex(0)->shape()->GetId());
+        ++p;
+        //        for(;
+        //        p!=pend;
+        //        ++p)
+        //        { 
+        //          WFace *f = (WFace*)((*p)->userdata);
+        //          ViewShape *vs = ioViewMap->viewShape(f->GetVertex(0)->shape()->GetId());
+        //          if(vs != vshape)
+        //          { 
+        //            sameShape = false;
+        //            break;
+        //          } 
+        //        } 
+        //        if(sameShape)
+        (*ve)->setaShape(vshape);
+      }
+    }
+    
+    //(*ve)->setaFace(aFace);
+    
+    if(progressBarDisplay) {  
+      counter--;
+      if (counter <= 0) {
+	counter = progressBarStep;
+	_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+      }
+    }
+    aFaces.clear();
+  }
+}
+
+void ViewMapBuilder::ComputeVeryFastRayCastingVisibility(ViewMap *ioViewMap, Grid* iGrid, real epsilon)
+{
+  vector<ViewEdge*>& vedges = ioViewMap->ViewEdges();
+  bool progressBarDisplay = false;
+  unsigned progressBarStep = 0;
+  unsigned vEdgesSize = vedges.size();
+  unsigned fEdgesSize = ioViewMap->FEdges().size();
+
+  if(_pProgressBar != NULL && fEdgesSize > gProgressBarMinSize) {
+    unsigned progressBarSteps = min(gProgressBarMaxSteps, vEdgesSize);
+    progressBarStep = vEdgesSize / progressBarSteps;
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Computing Ray casting Visibility");
+    _pProgressBar->setTotalSteps(progressBarSteps);
+    _pProgressBar->setProgress(0);
+    progressBarDisplay = true;
+  }
+
+  unsigned counter = progressBarStep;
+  FEdge* fe;
+  unsigned qi = 0;
+  Polygon3r *aFace = 0;
+  static unsigned timestamp = 1;
+  for(vector<ViewEdge*>::iterator ve=vedges.begin(), veend=vedges.end();
+  ve!=veend;
+  ve++)
+  {
+    set<ViewShape*> occluders;
+
+    fe = (*ve)->fedgeA();
+    qi = ComputeRayCastingVisibility(fe, iGrid, epsilon, occluders, &aFace, timestamp++);
+    if(aFace)
+    { 
+      fe->setaFace(*aFace);
+      WFace * wface = (WFace*)(aFace->userdata);
+      ViewShape *vshape = ioViewMap->viewShape(wface->GetVertex(0)->shape()->GetId());
+      (*ve)->setaShape(vshape);
+    } 
+    else
+    {
+      (*ve)->setaShape(0);
+    }
+
+    (*ve)->setQI(qi);
+    
+    if(progressBarDisplay) {  
+      counter--;
+      if (counter <= 0) {
+	counter = progressBarStep;
+	_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+      }
+    }
+  }  
+}
+
+
+void ViewMapBuilder::FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp, 
+				  Vec3r& u, Vec3r& A, Vec3r& origin, Vec3r& edge, vector<WVertex*>& faceVertices)
+{
+  WFace *face = 0;
+  if(fe->isSmooth()){
+    FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+    face = (WFace*)fes->face();
+  }
+  OccludersSet occluders;
+  WFace * oface;
+  bool skipFace;
+  
+  WVertex::incoming_edge_iterator ie;
+  OccludersSet::iterator p, pend;
+  
+  *oaPolygon = 0;
+  if(((fe)->getNature() & Nature::SILHOUETTE) || ((fe)->getNature() & Nature::BORDER))
+  {
+    occluders.clear();
+    // we cast a ray from A in the same direction but looking behind
+    Vec3r v(-u[0],-u[1],-u[2]);
+    iGrid->castInfiniteRay(A, v, occluders, timestamp);
+    
+    bool noIntersection = true;
+    real mint=FLT_MAX;
+    // we met some occluders, let us fill the aShape field 
+    // with the first intersected occluder
+    for(p=occluders.begin(),pend=occluders.end();
+    p!=pend;
+    p++)
+    { 
+      // check whether the edge and the polygon plane are coincident:
+      //-------------------------------------------------------------
+      //first let us compute the plane equation.
+      oface = (WFace*)(*p)->userdata;
+      Vec3r v1(((*p)->getVertices())[0]);
+      Vec3r normal((*p)->getNormal());
+      real d = -(v1 * normal);
+      real t,t_u,t_v;
+      
+      if(0 != face)
+      { 
+        skipFace = false;
+        
+        if(face == oface)
+          continue;
+        
+        if(faceVertices.empty())
+          continue;
+        
+        for(vector<WVertex*>::iterator fv=faceVertices.begin(), fvend=faceVertices.end();
+        fv!=fvend;
+        ++fv)
+        { 
+          if((*fv)->isBoundary())
+            continue;
+          WVertex::incoming_edge_iterator iebegin=(*fv)->incoming_edges_begin();
+          WVertex::incoming_edge_iterator ieend=(*fv)->incoming_edges_end();
+          for(ie=iebegin;ie!=ieend; ++ie)
+          {  
+            if((*ie) == 0)
+              continue;
+            
+            WFace * sface = (*ie)->GetbFace();
+            if(sface == oface)
+            { 
+              skipFace = true;
+              break;
+            } 
+          }  
+          if(skipFace)
+            break;
+        } 
+        if(skipFace)
+          continue;
+      }  
+      else
+      {
+        if(GeomUtils::COINCIDENT == GeomUtils::intersectRayPlane(origin, edge, normal, d, t, epsilon))
+          continue;
+      }
+      if((*p)->rayIntersect(A, v, t,t_u,t_v))
+      {
+        if (fabs(v * normal) > 0.0001)
+          if ((t>0.0)) // && (t<1.0))
+          {
+            if (t<mint)
+            {
+              *oaPolygon = (*p);
+              mint = t;
+              noIntersection = false;
+              fe->setOccludeeIntersection(Vec3r(A+t*v));
+            }
+          }
+      }  
+    }
+    
+    if(noIntersection)
+      *oaPolygon = 0;
+  }
+}
+
+void ViewMapBuilder::FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp)
+{
+  OccludersSet occluders;
+
+  Vec3r A;
+  Vec3r edge;
+  Vec3r origin;
+  A = Vec3r(((fe)->vertexA()->point3D() + (fe)->vertexB()->point3D())/2.0);
+  edge = Vec3r((fe)->vertexB()->point3D()-(fe)->vertexA()->point3D());
+  origin = Vec3r((fe)->vertexA()->point3D());
+  Vec3r u(_viewpoint-A);
+  u.normalize();
+  if(A < iGrid->getOrigin())
+    cerr << "Warning: point is out of the grid for fedge " << fe->getId().getFirst() << "-" << fe->getId().getSecond() << endl;
+
+  vector<WVertex*> faceVertices;
+     
+  WFace *face = 0;
+  if(fe->isSmooth()){
+    FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+    face = (WFace*)fes->face();
+  }
+  if(0 != face)
+    face->RetrieveVertexList(faceVertices);
+  
+  return FindOccludee(fe,iGrid, epsilon, oaPolygon, timestamp, 
+		      u, A, origin, edge, faceVertices);
+}
+
+int ViewMapBuilder::ComputeRayCastingVisibility(FEdge *fe, Grid* iGrid, real epsilon, set<ViewShape*>& oOccluders,
+						Polygon3r** oaPolygon, unsigned timestamp)
+{
+  OccludersSet occluders;
+  int qi = 0;
+
+  Vec3r center;
+  Vec3r edge;
+  Vec3r origin;
+
+  center = fe->center3d();
+  edge = Vec3r(fe->vertexB()->point3D() - fe->vertexA()->point3D());
+  origin = Vec3r(fe->vertexA()->point3D());
+  //
+  //   // Is the edge outside the view frustum ?
+  Vec3r gridOrigin(iGrid->getOrigin());
+  Vec3r gridExtremity(iGrid->getOrigin()+iGrid->gridSize());
+  
+  if( (center.x() < gridOrigin.x()) || (center.y() < gridOrigin.y()) || (center.z() < gridOrigin.z())
+    ||(center.x() > gridExtremity.x()) || (center.y() > gridExtremity.y()) || (center.z() > gridExtremity.z())){
+     cerr << "Warning: point is out of the grid for fedge " << fe->getId() << endl;
+    //return 0;
+  }
+
+ 
+  //  Vec3r A(fe->vertexA()->point2d());
+  //  Vec3r B(fe->vertexB()->point2d());
+  //  int viewport[4];
+  //  SilhouetteGeomEngine::retrieveViewport(viewport);
+  //  if( (A.x() < viewport[0]) || (A.x() > viewport[2]) || (A.y() < viewport[1]) || (A.y() > viewport[3])
+  //    ||(B.x() < viewport[0]) || (B.x() > viewport[2]) || (B.y() < viewport[1]) || (B.y() > viewport[3])){
+  //    cerr << "Warning: point is out of the grid for fedge " << fe->getId() << endl;
+  //    //return 0;
+  //  }
+
+  Vec3r u(_viewpoint - center);
+  real raylength = u.norm();
+  u.normalize();
+  //cout << "grid origin " << iGrid->getOrigin().x() << "," << iGrid->getOrigin().y() << "," << iGrid->getOrigin().z() << endl;
+  //cout << "center " << center.x() << "," << center.y() << "," << center.z() << endl;
+  
+  iGrid->castRay(center, Vec3r(_viewpoint), occluders, timestamp);
+
+  WFace *face = 0;
+  if(fe->isSmooth()){
+    FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
+    face = (WFace*)fes->face();
+  }
+  vector<WVertex*> faceVertices;
+  WVertex::incoming_edge_iterator ie;
+            
+  WFace * oface;
+  bool skipFace;
+  OccludersSet::iterator p, pend;
+  if(face)
+    face->RetrieveVertexList(faceVertices);
+
+  for(p=occluders.begin(),pend=occluders.end();
+      p!=pend;
+      p++)
+    { 
+      // If we're dealing with an exact silhouette, check whether 
+      // we must take care of this occluder of not.
+      // (Indeed, we don't consider the occluders that 
+      // share at least one vertex with the face containing 
+      // this edge).
+      //-----------
+      oface = (WFace*)(*p)->userdata;
+      Vec3r v1(((*p)->getVertices())[0]);
+      Vec3r normal((*p)->getNormal());
+      real d = -(v1 * normal);
+      real t, t_u, t_v;
+            
+      if(0 != face)
+	{
+	  skipFace = false;
+              
+	  if(face == oface)
+	    continue;
+              
+              
+	  for(vector<WVertex*>::iterator fv=faceVertices.begin(), fvend=faceVertices.end();
+              fv!=fvend;
+              ++fv)
+	    {
+                if((*fv)->isBoundary())
+                  continue;
+
+	      WVertex::incoming_edge_iterator iebegin=(*fv)->incoming_edges_begin();
+	      WVertex::incoming_edge_iterator ieend=(*fv)->incoming_edges_end();
+	      for(ie=iebegin;ie!=ieend; ++ie)
+                { 
+                  if((*ie) == 0)
+                    continue;
+                  
+                  WFace * sface = (*ie)->GetbFace();
+                  //WFace * sfacea = (*ie)->GetaFace();
+                  //if((sface == oface) || (sfacea == oface))
+                  if(sface == oface)
+		    {
+		      skipFace = true;
+		      break;
+		    }
+                }
+	      if(skipFace)
+		break;
+	    }
+	  if(skipFace)
+	    continue;
+	}
+      else
+	{
+	  // check whether the edge and the polygon plane are coincident:
+	  //-------------------------------------------------------------
+	  //first let us compute the plane equation.
+           
+	  if(GeomUtils::COINCIDENT == GeomUtils::intersectRayPlane(origin, edge, normal, d, t, epsilon))
+	    continue;
+	}
+
+      if((*p)->rayIntersect(center, u, t, t_u, t_v))
+	{
+	  if (fabs(u * normal) > 0.0001)
+	    if ((t>0.0) && (t<raylength))
+	      {
+		WFace *f = (WFace*)((*p)->userdata);
+		ViewShape *vshape = _ViewMap->viewShape(f->GetVertex(0)->shape()->GetId());
+		oOccluders.insert(vshape);
+		++qi;
+    if(!_EnableQI)
+      break;
+	      }
+	}
+    }
+
+  // Find occludee
+  FindOccludee(fe,iGrid, epsilon, oaPolygon, timestamp, 
+	       u, center, edge, origin, faceVertices);
+
+  return qi;
+}
+
+void ViewMapBuilder::ComputeIntersections(ViewMap *ioViewMap, intersection_algo iAlgo, real epsilon)
+{
+  switch(iAlgo)
+  {
+  case sweep_line:
+    ComputeSweepLineIntersections(ioViewMap, epsilon);
+    break;
+  default:
+    break;
+  }
+  ViewMap::viewvertices_container& vvertices = ioViewMap->ViewVertices();
+  for(ViewMap::viewvertices_container::iterator vv=vvertices.begin(), vvend=vvertices.end();
+  vv!=vvend;
+  ++vv)
+  {
+    if((*vv)->getNature() == Nature::T_VERTEX)
+    {
+      TVertex *tvertex = (TVertex*)(*vv);
+      cout << "TVertex " << tvertex->getId() << " has :" << endl;
+      cout << "FrontEdgeA: " << tvertex->frontEdgeA().first << endl;
+      cout << "FrontEdgeB: " << tvertex->frontEdgeB().first << endl;
+      cout << "BackEdgeA: " << tvertex->backEdgeA().first << endl;
+      cout << "BackEdgeB: " << tvertex->backEdgeB().first << endl << endl;
+    }
+  }
+}
+
+struct less_SVertex2D : public binary_function<SVertex*, SVertex*, bool> 
+{
+  real epsilon;
+  less_SVertex2D(real eps)
+    : binary_function<SVertex*,SVertex*,bool>()
+  {
+    epsilon = eps;
+  }
+	bool operator()(SVertex* x, SVertex* y) 
+  {
+    Vec3r A = x->point2D();
+    Vec3r B = y->point2D();
+    for(unsigned int i=0; i<3; i++)
+    {
+      if((fabs(A[i] - B[i])) < epsilon)
+        continue;
+      if(A[i] < B[i])
+        return true;
+      if(A[i] > B[i])
+        return false;
+    }
+    
+    return false;
+  }
+};
+
+typedef Segment<FEdge*,Vec3r > segment;
+typedef Intersection<segment> intersection;
+
+struct less_Intersection : public binary_function<intersection*, intersection*, bool> 
+{
+  segment *edge;
+  less_Intersection(segment *iEdge)
+    : binary_function<intersection*,intersection*,bool>()
+  {
+    edge = iEdge;
+  }
+	bool operator()(intersection* x, intersection* y) 
+  {
+    real tx = x->getParameter(edge);
+    real ty = y->getParameter(edge);
+    if(tx > ty)
+      return true;
+    return false;
+  }
+};
+
+struct silhouette_binary_rule : public binary_rule<segment,segment>
+{
+  silhouette_binary_rule() : binary_rule<segment,segment>() {}
+  virtual bool operator() (segment& s1, segment& s2)
+  {
+    FEdge * f1 = s1.edge();
+    FEdge * f2 = s2.edge();
+
+    if((!(((f1)->getNature() & Nature::SILHOUETTE) || ((f1)->getNature() & Nature::BORDER))) && (!(((f2)->getNature() & Nature::SILHOUETTE) || ((f2)->getNature() & Nature::BORDER))))
+      return false;
+      
+    return true;
+  }
+};
+
+void ViewMapBuilder::ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon)
+{
+  vector<SVertex*>& svertices = ioViewMap->SVertices();
+  bool progressBarDisplay = false;
+  unsigned sVerticesSize = svertices.size();
+  unsigned fEdgesSize = ioViewMap->FEdges().size();
+  //  ViewMap::fedges_container& fedges = ioViewMap->FEdges();
+  //  for(ViewMap::fedges_container::const_iterator f=fedges.begin(), end=fedges.end();
+  //  f!=end;
+  //  ++f){
+  //    cout << (*f)->aMaterialIndex() << "-" << (*f)->bMaterialIndex() << endl;
+  //  }
+    
+  unsigned progressBarStep = 0;
+  
+  if(_pProgressBar != NULL && fEdgesSize > gProgressBarMinSize) {
+    unsigned progressBarSteps = min(gProgressBarMaxSteps, sVerticesSize);
+    progressBarStep = sVerticesSize / progressBarSteps;
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Computing Sweep Line Intersections");
+    _pProgressBar->setTotalSteps(progressBarSteps);
+    _pProgressBar->setProgress(0);
+    progressBarDisplay = true;
+  }
+  
+  unsigned counter = progressBarStep;
+
+  sort(svertices.begin(), svertices.end(), less_SVertex2D(epsilon));
+
+  SweepLine<FEdge*,Vec3r> SL;
+
+  vector<FEdge*>& ioEdges = ioViewMap->FEdges();
+
+  vector<segment* > segments;
+
+  vector<FEdge*>::iterator fe,fend;
+
+  for(fe=ioEdges.begin(), fend=ioEdges.end();
+  fe!=fend;
+  fe++)
+  {
+    segment * s = new segment((*fe), (*fe)->vertexA()->point2D(), (*fe)->vertexB()->point2D());
+    (*fe)->userdata = s;    
+    segments.push_back(s);
+  }
+
+  vector<segment*> vsegments;
+  for(vector<SVertex*>::iterator sv=svertices.begin(),svend=svertices.end();
+  sv!=svend;
+  sv++)
+  {
+    const vector<FEdge*>& vedges = (*sv)->fedges();
+    
+    for(vector<FEdge*>::const_iterator sve=vedges.begin(), sveend=vedges.end();
+    sve!=sveend;
+    sve++)
+    {
+      vsegments.push_back((segment*)((*sve)->userdata));
+    }
+
+    Vec3r evt((*sv)->point2D());
+    silhouette_binary_rule sbr;
+    SL.process(evt, vsegments, sbr);
+
+    if(progressBarDisplay) {  
+      counter--;
+      if (counter <= 0) {
+	counter = progressBarStep;
+	_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+      }
+    }
+    vsegments.clear();
+  }
+
+  // reset userdata:
+  for(fe=ioEdges.begin(), fend=ioEdges.end();
+  fe!=fend;
+  fe++)
+    (*fe)->userdata = NULL;
+ 
+  // list containing the new edges resulting from splitting operations. 
+  vector<FEdge*> newEdges;
+  
+  // retrieve the intersected edges:
+  vector<segment* >& iedges = SL.intersectedEdges();
+  // retrieve the intersections:
+  vector<intersection*>& intersections = SL.intersections();
+  
+  int id=0;
+  // create a view vertex for each intersection and linked this one 
+  // with the intersection object
+  vector<intersection*>::iterator i, iend;
+  for(i=intersections.begin(),iend=intersections.end();
+  i!=iend;
+  i++)
+  {
+    FEdge *fA = (*i)->EdgeA->edge();
+    FEdge *fB = (*i)->EdgeB->edge();
+    
+    Vec3r A1 = fA->vertexA()->point3D();
+    Vec3r A2 = fA->vertexB()->point3D();
+    Vec3r B1 = fB->vertexA()->point3D();
+    Vec3r B2 = fB->vertexB()->point3D();
+
+    Vec3r a1 = fA->vertexA()->point2D();
+    Vec3r a2 = fA->vertexB()->point2D();
+    Vec3r b1 = fB->vertexA()->point2D();
+    Vec3r b2 = fB->vertexB()->point2D();
+
+    real ta = (*i)->tA;
+    real tb = (*i)->tB;
+
+    if((ta < -epsilon) || (ta > 1+epsilon))
+        cerr << "Warning: intersection out of range for edge " << fA->vertexA()->getId() << " - " << fA->vertexB()->getId() << endl;
+    
+    if((tb < -epsilon) || (tb > 1+epsilon))
+        cerr << "Warning: intersection out of range for edge " << fB->vertexA()->getId() << " - " << fB->vertexB()->getId() << endl;
+    
+    real Ta = SilhouetteGeomEngine::ImageToWorldParameter(fA, ta);
+    real Tb = SilhouetteGeomEngine::ImageToWorldParameter(fB, tb);
+
+    TVertex * tvertex = ioViewMap->CreateTVertex(Vec3r(A1 + Ta*(A2-A1)), Vec3r(a1 + ta*(a2-a1)), fA, 
+                                                 Vec3r(B1 + Tb*(B2-B1)), Vec3r(b1 + tb*(b2-b1)), fB, id);
+     
+    (*i)->userdata = tvertex;
+    ++id;
+  }
+
+  progressBarStep = 0;
+
+  if(progressBarDisplay) {
+    unsigned iEdgesSize = iedges.size();
+    unsigned progressBarSteps = min(gProgressBarMaxSteps, iEdgesSize);
+    progressBarStep = iEdgesSize / progressBarSteps;
+    _pProgressBar->reset();
+    _pProgressBar->setLabelText("Splitting intersected edges");
+    _pProgressBar->setTotalSteps(progressBarSteps);
+    _pProgressBar->setProgress(0);
+  }
+  
+  counter = progressBarStep;
+
+  vector<TVertex*> edgeVVertices;
+  vector<ViewEdge*> newVEdges;
+  vector<segment* >::iterator s, send;
+  for(s=iedges.begin(),send=iedges.end();
+  s!=send;
+  s++)
+  {
+    edgeVVertices.clear();
+    newEdges.clear();
+    newVEdges.clear();
+    
+    FEdge* fedge = (*s)->edge();
+    ViewEdge *vEdge = fedge->viewedge();
+    ViewShape *shape = vEdge->viewShape();
+    
+    vector<intersection*>& eIntersections = (*s)->intersections();
+    // we first need to sort these intersections from farther to closer to A
+    sort(eIntersections.begin(), eIntersections.end(), less_Intersection(*s));
+    for(i=eIntersections.begin(),iend=eIntersections.end();
+    i!=iend;
+    i++)
+      edgeVVertices.push_back((TVertex*)(*i)->userdata);
+
+    shape->SplitEdge(fedge, edgeVVertices, ioViewMap->FEdges(), ioViewMap->ViewEdges()); 
+
+    if(progressBarDisplay) {  
+      counter--;
+      if (counter <= 0) {
+	counter = progressBarStep;
+	_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
+      }
+    }
+  }
+
+  // reset userdata:
+  for(fe=ioEdges.begin(), fend=ioEdges.end();
+  fe!=fend;
+  fe++)
+    (*fe)->userdata = NULL;
+
+  // delete segments
+  //  if(!segments.empty()){
+  //    for(s=segments.begin(),send=segments.end();
+  //    s!=send;
+  //    s++){
+  //      delete *s;
+  //    }
+  //    segments.clear();
+  //  }
+}
diff --git a/source/blender/freestyle/intern/view_map/ViewMapBuilder.h b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h
new file mode 100755
index 00000000000..5ac100bae15
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h
@@ -0,0 +1,224 @@
+//
+//  Filename         : ViewMapBuilder.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to build silhouette edges from a
+//                     Winged-Edge structure
+//  Date of creation : 25/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAPBUILDER_H
+# define VIEWMAPBUILDER_H
+
+# include <vector>
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+# include "../scene_graph/NodeGroup.h"
+# include "../winged_edge/WXEdge.h"
+# include "Silhouette.h"
+# include "../geometry/GeomUtils.h"
+# include "../geometry/Grid.h"
+# include "../system/ProgressBar.h"
+# include "../geometry/SweepLine.h"
+# include "ViewMap.h"
+# include "SilhouetteGeomEngine.h"
+# include "../scene_graph/TriangleRep.h"
+# include "../winged_edge/WEdge.h"
+# include "ViewEdgeXBuilder.h"
+
+
+using namespace Geometry;
+
+class LIB_VIEW_MAP_EXPORT ViewMapBuilder
+{
+private:
+
+  ViewMap * _ViewMap; // result
+  //SilhouetteGeomEngine _GeomEngine;
+  ProgressBar *_pProgressBar;
+  Vec3r _viewpoint;
+  Grid* _Grid;
+  ViewEdgeXBuilder *_pViewEdgeBuilder;
+  bool _EnableQI;
+  double _epsilon;
+
+  // tmp values:
+  int _currentId;
+  int _currentFId;
+  int _currentSVertexId;
+  
+
+public:
+
+  typedef enum {
+    sweep_line
+  } intersection_algo;
+
+  typedef enum {
+    ray_casting,
+    ray_casting_fast,
+    ray_casting_very_fast
+  } visibility_algo;
+
+  inline ViewMapBuilder()
+  {
+    _pProgressBar = 0;
+    _Grid = 0;
+    _currentId = 1;
+    _currentFId = 0;
+    _currentSVertexId = 0;
+    _pViewEdgeBuilder = new ViewEdgeXBuilder;
+    _EnableQI = true;
+  }
+
+  inline ~ViewMapBuilder() 
+  {
+    if(_pViewEdgeBuilder){
+      delete _pViewEdgeBuilder;
+      _pViewEdgeBuilder = 0;
+    }
+  }
+
+  /*! Compute Shapes from a WingedEdge containing a list of WShapes */
+  void computeInitialViewEdges(WingedEdge&);
+
+  /*! Compute Cusps */
+  void computeCusps(ViewMap *ioViewMap);
+  /*! Detects cusps (for a single ViewEdge) among SVertices and builds a ViewVertex on top of 
+   *  each cusp SVertex
+   *  We use a hysteresis approach to avoid noise.
+   */
+  void DetectCusps(ViewEdge *ioEdge);
+
+
+  /*! Sets the current viewpoint */
+  inline void setViewpoint(const Vec3r& ivp) {_viewpoint = ivp; SilhouetteGeomEngine::setViewpoint(ivp);}
+
+  /*! Sets the current transformation
+   *    iModelViewMatrix
+   *      The 4x4 model view matrix, in column major order (openGL like).
+   *    iProjection matrix
+   *      The 4x4 projection matrix, in column major order (openGL like).
+   *    iViewport
+   *      The viewport. 4 real array: origin.x, origin.y, width, length
+   */
+  inline void setTransform(const real iModelViewMatrix[4][4],
+			   const real iProjectionMatrix[4][4],
+			   const int iViewport[4],
+			   real iFocalLength,
+			   real iAspect,
+			   real iFovy) {
+    SilhouetteGeomEngine::setTransform(iModelViewMatrix, iProjectionMatrix, iViewport, iFocalLength);
+  }
+  
+  inline void setFrustum(real iZnear, real iZfar) {
+    SilhouetteGeomEngine::setFrustum(iZnear, iZfar);
+  }
+
+  /*! Builds the scene view map
+   *  returns the list the view map
+   *  it is up to the caller to delete this ViewMap
+   *    iWRoot
+   *      The root group node containing the WEdge structured scene 
+   */
+
+  ViewMap* BuildViewMap(WingedEdge& we, visibility_algo iAlgo = ray_casting, real epsilon=1e-06) ;
+  /*! computes the intersection between all 2D
+   *  feature edges of the scene.
+   *    ioViewMap
+   *      The view map. It is modified by the method.
+   *      The list of all features edges of the scene.
+   *      Each time an intersection is found, the 2 intersecting
+   *      edges are splitted (creating 2 new vertices)
+   *      At the end, this list is updated with the adding
+   *      of all new created edges (resulting from splitting).
+   *    iAlgo
+   *      The algo to use for computing the intersections
+   */
+  void ComputeIntersections(ViewMap *ioViewMap, intersection_algo iAlgo = sweep_line, real epsilon=1e-06);
+
+  /*! Computes the 2D scene silhouette edges visibility
+   *    iGrid
+   *      For the Ray Casting algorithm. 
+   */
+  void ComputeEdgesVisibility(ViewMap *ioViewMap, visibility_algo iAlgo= ray_casting, Grid* iGrid = 0, real epsilon=1e-6);
+
+  void setGrid(Grid *iGrid) {_Grid = iGrid;}
+  
+  /*! accessors */
+ 
+  /*! Modifiers */
+  inline void setProgressBar(ProgressBar *iProgressBar) {_pProgressBar = iProgressBar;}
+  inline void setEnableQI(bool iBool) {_EnableQI = iBool;}
+
+protected:
+
+  /*! Computes intersections on all edges of the scene using a sweep line 
+   *  algorithm*/
+  void ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon = 1e-6);
+
+  /*! Computes the 2D scene silhouette edges visibility
+   *  using a ray casting. On each edge, a ray is cast
+   *  to check its quantitative invisibility. The list
+   *  of occluders are each time stored in the tested edge.
+   *    ioViewMap
+   *      The view map.
+   *      The 2D scene silhouette edges as FEdges.
+   *      These edges have already been splitted at their intersections points.
+   *      Thus, these edges do not intersect anymore.
+   *      The visibility corresponding to each edge of ioScene is set is this
+   *      edge.
+   */
+  void ComputeRayCastingVisibility(ViewMap *ioViewMap, Grid *iGrid, real epsilon=1e-6);
+  void ComputeFastRayCastingVisibility(ViewMap *ioViewMap, Grid *iGrid, real epsilon=1e-6);
+  void ComputeVeryFastRayCastingVisibility(ViewMap *ioViewMap, Grid *iGrid, real epsilon=1e-6);
+
+  /*! Compute the visibility for the FEdge fe.
+   *  The occluders are added to fe occluders list.
+   *    fe
+   *      The FEdge
+   *    iGrid
+   *      The grid used to compute the ray casting visibility
+   *    epsilon
+   *      The epsilon used for computation
+   *    oShapeId
+   *      fe is the border (in 2D) between 2 2D spaces.
+   *      if fe is a silhouette,
+   *      One of these 2D spaces is occupied by the shape
+   *      to which fe belongs (on its left) and the other one is either occupied 
+   *      by another shape or empty or occupied by the same shape.
+   *      We use this ray csating operation to determine which shape 
+   *      lies on fe's right.
+   *      The result is the shape id stored in oShapeId
+   */
+  int ComputeRayCastingVisibility(FEdge *fe, Grid* iGrid, real epsilon, set<ViewShape*>& oOccluders,
+                                  Polygon3r** oaPolygon, unsigned timestamp);
+  // FIXME
+  void FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp);
+  void FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp,
+                    Vec3r& u, Vec3r& A, Vec3r& origin, Vec3r& edge, vector<WVertex*>& faceVertices);
+
+};
+
+#endif // VIEWMAPBUILDER_H
diff --git a/source/blender/freestyle/intern/view_map/ViewMapIO.cpp b/source/blender/freestyle/intern/view_map/ViewMapIO.cpp
new file mode 100755
index 00000000000..370f44dffcf
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapIO.cpp
@@ -0,0 +1,1245 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ViewMapIO.h"
+
+#ifdef IRIX
+# define WRITE(n)			Internal::write<sizeof((n))>(out, (const char*)(&(n)))
+# define READ(n)			Internal::read<sizeof((n))>(in, (char*)(&(n)))
+#else
+# define WRITE(n)			out.write((const char*)(&(n)), sizeof((n)))
+# define READ(n)			in.read((char*)(&(n)), sizeof((n)))
+#endif
+
+#define WRITE_IF_NON_NULL(ptr)		if ((ptr) == NULL) { WRITE(ZERO); } else { WRITE((ptr)->userdata); }
+#define READ_IF_NON_NULL(ptr, array)	READ(tmp); if (tmp == ZERO) { (ptr) = NULL; } else { (ptr) = (array)[tmp]; }
+
+namespace ViewMapIO {
+
+  namespace Internal {
+
+    ViewMap* g_vm;
+
+    //////////////////// 'load' Functions ////////////////////
+
+    inline
+    int load(istream& in, Vec3r& v) {
+
+      if (Options::getFlags() & Options::FLOAT_VECTORS) {
+	float tmp;
+	READ(tmp);
+	v[0] = tmp;
+	READ(tmp);
+	v[1] = tmp;
+	READ(tmp);
+	v[2] = tmp;
+      } else {
+	Vec3r::value_type tmp;
+	READ(tmp);
+	v[0] = tmp;
+	READ(tmp);
+	v[1] = tmp;
+	READ(tmp);
+	v[2] = tmp;
+      }
+      return 0;
+    }
+
+
+    inline
+    int load(istream& in, Polygon3r& p) {
+
+      unsigned tmp;
+
+      // Id
+      READ(tmp);
+      p.setId(tmp);
+
+      // vertices (List)
+      vector<Vec3r> tmp_vec;
+      Vec3r v;
+      READ(tmp);
+      for (unsigned i = 0; i < tmp; i++) {
+	load(in, v);
+	tmp_vec.push_back(v);
+      }
+      p.setVertices(tmp_vec);
+
+      // min & max
+      // Already computed (in the SetVertices() method)
+
+      return 0;
+    }
+
+
+    inline
+    int load(istream& in, Material& m) {
+
+      float tmp_array[4];
+      int i;
+
+      // Diffuse
+      for (i = 0; i < 4; i++)
+	READ(tmp_array[i]);
+      m.setDiffuse(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
+
+      // Specular
+      for (i = 0; i < 4; i++)
+	READ(tmp_array[i]);
+      m.setSpecular(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
+
+      // Ambient
+      for (i = 0; i < 4; i++)
+	READ(tmp_array[i]);
+      m.setAmbient(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
+
+      // Emission
+      for (i = 0; i < 4; i++)
+	READ(tmp_array[i]);
+      m.setEmission(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
+
+      // Shininess
+      READ(tmp_array[0]);
+      m.setShininess(tmp_array[0]);
+
+      return 0;
+    }
+
+
+    int load(istream& in, ViewShape* vs) {
+
+      if (!vs || !vs->sshape())
+	return 1;
+
+      // SShape
+
+      // -> Id
+      Id::id_type id1, id2;
+      READ(id1);
+      READ(id2);
+      vs->sshape()->setId(Id(id1, id2));
+
+      // -> Importance
+      float importance;
+      READ(importance);
+      vs->sshape()->setImportance(importance);
+
+      // -> BBox
+      //    Not necessary (only used during view map computatiom)
+
+      unsigned i, size, tmp;
+
+      // -> Material
+      READ(size);
+      vector<Material> materials;
+      Material m;
+      for(i=0; i<size; ++i){
+        load(in, m);
+        materials.push_back(m);
+      }
+      vs->sshape()->setMaterials(materials);
+
+      
+
+      // -> VerticesList (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	SVertex* sv;
+	READ_IF_NON_NULL(sv, g_vm->SVertices());
+	vs->sshape()->AddNewVertex(sv);
+      }
+
+       // -> Chains (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	FEdge* fe;
+	READ_IF_NON_NULL(fe, g_vm->FEdges());
+	vs->sshape()->AddChain(fe);
+      }
+
+      // -> EdgesList (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	FEdge* fe;
+	READ_IF_NON_NULL(fe, g_vm->FEdges());
+	vs->sshape()->AddEdge(fe);
+      }
+
+      // ViewEdges (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	ViewEdge* ve;
+	READ_IF_NON_NULL(ve, g_vm->ViewEdges());
+	vs->AddEdge(ve);
+      }
+
+      // ViewVertices (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	ViewVertex* vv;
+	READ_IF_NON_NULL(vv, g_vm->ViewVertices());
+	vs->AddVertex(vv);
+      }
+
+      return 0;
+    }
+
+
+    int load(istream& in, FEdge* fe) {
+
+      if (!fe)
+	return 1;
+
+      bool b;
+
+      FEdgeSmooth *fesmooth = 0;
+      FEdgeSharp * fesharp  = 0;
+      if(fe->isSmooth()){
+        fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
+      }else{
+        fesharp = dynamic_cast<FEdgeSharp*>(fe);
+      }
+
+      // Id
+      Id::id_type id1, id2;
+      READ(id1);
+      READ(id2);
+      fe->setId(Id(id1, id2));
+
+      // Nature
+      Nature::EdgeNature nature;
+      READ(nature);
+      fe->setNature(nature);
+
+      // hasVisibilityPoint
+      //      bool b;
+      //      READ(b);
+      //      fe->setHasVisibilityPoint(b);
+ 
+      Vec3r v;
+      unsigned int matindex;
+
+      // VisibilityPointA
+      //      load(in, v);
+      //      fe->setVisibilityPointA(v);
+
+      // VisibilityPointB
+      //      load(in, v);
+      //      fe->setVisibilityPointB(v);
+
+      if(fe->isSmooth()){
+        // Normal
+        load(in, v);
+        fesmooth->setNormal(v);
+
+        // Material
+        READ(matindex);
+        fesmooth->setMaterialIndex(matindex);
+      }else{
+        // aNormal
+        load(in, v);
+        fesharp->setNormalA(v);
+
+        // bNormal
+        load(in, v);
+        fesharp->setNormalB(v);
+
+        // Materials 
+        READ(matindex);
+        fesharp->setaMaterialIndex(matindex);
+        READ(matindex);
+        fesharp->setbMaterialIndex(matindex);
+      }
+      
+      unsigned tmp;
+
+      // VertexA
+      SVertex* sva;
+      READ_IF_NON_NULL(sva, g_vm->SVertices());
+      fe->setVertexA(sva);
+     
+      // VertexB
+      SVertex* svb;
+      READ_IF_NON_NULL(svb, g_vm->SVertices());
+      fe->setVertexB(svb);
+
+      // NextEdge
+      FEdge* nfe;
+      READ_IF_NON_NULL(nfe, g_vm->FEdges());
+      fe->setNextEdge(nfe);
+
+      // PreviousEdge
+      FEdge* pfe;
+      READ_IF_NON_NULL(pfe, g_vm->FEdges());
+      fe->setPreviousEdge(pfe);
+
+      // ViewEdge
+      ViewEdge* ve;
+      READ_IF_NON_NULL(ve, g_vm->ViewEdges());
+      fe->setViewEdge(ve);
+
+      // Face
+      // Not necessary (only used during view map computatiom)
+
+      Polygon3r p;
+    
+      // aFace
+      load(in, p);
+      fe->setaFace(p);
+
+      // occludeeEmpty
+      READ(b);
+      fe->setOccludeeEmpty(b);
+      
+      // occludeeIntersection
+      load(in, v);
+      fe->setOccludeeIntersection(v);
+
+      return 0;
+    }
+
+
+    int load(istream& in, SVertex* sv) {
+
+      if (!sv)
+	return 1;
+
+      // Id
+      Id::id_type id1, id2;
+      READ(id1);
+      READ(id2);
+      sv->setId(Id(id1, id2));
+
+      Vec3r v;
+
+      // Point3D
+      load(in, v);
+      sv->setPoint3D(v);
+
+      // Point2D
+      load(in, v);
+      sv->setPoint2D(v);
+
+      unsigned tmp;
+
+      // Shape
+      ViewShape* vs;
+      READ_IF_NON_NULL(vs, g_vm->ViewShapes());
+      sv->setShape(vs->sshape());
+
+      // pViewVertex
+      ViewVertex* vv;
+      READ_IF_NON_NULL(vv, g_vm->ViewVertices());
+      sv->setViewVertex(vv);
+
+      unsigned i, size;
+
+      // Normals (List)
+      READ(size);
+      for (i = 0; i < size; i++) {
+	load(in, v);
+	sv->AddNormal(v);
+      }
+
+      // FEdges (List)
+      READ(size);
+      FEdge* fe;
+      for (i = 0; i < size; i++) {
+	READ_IF_NON_NULL(fe, g_vm->FEdges());
+	sv->AddFEdge(fe);
+      }
+
+      return 0;
+    }
+
+
+    int load(istream& in, ViewEdge* ve) {
+
+      if (!ve)
+	return 1;
+
+      unsigned tmp;
+
+      // Id
+      Id::id_type id1, id2;
+      READ(id1);
+      READ(id2);
+      ve->setId(Id(id1, id2));
+
+      // Nature
+      Nature::EdgeNature nature;
+      READ(nature);
+      ve->setNature(nature);
+
+      // QI
+      READ(tmp);
+      ve->setQI(tmp);
+
+      // Shape
+      ViewShape* vs;
+      READ_IF_NON_NULL(vs, g_vm->ViewShapes());
+      ve->setShape(vs);
+
+      // aShape
+      ViewShape* avs;
+      READ_IF_NON_NULL(avs, g_vm->ViewShapes());
+      ve->setaShape(avs);
+
+      // FEdgeA
+      FEdge* fea;
+      READ_IF_NON_NULL(fea, g_vm->FEdges());
+      ve->setFEdgeA(fea);
+
+      // FEdgeB
+      FEdge* feb;
+      READ_IF_NON_NULL(feb, g_vm->FEdges());
+      ve->setFEdgeB(feb);
+
+      // A
+      ViewVertex* vva;
+      READ_IF_NON_NULL(vva, g_vm->ViewVertices());
+      ve->setA(vva);
+
+      // B
+      ViewVertex* vvb;
+      READ_IF_NON_NULL(vvb, g_vm->ViewVertices());
+      ve->setB(vvb);
+
+      // Occluders (List)
+      if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
+	unsigned size;
+	READ(size);
+	ViewShape* vso;
+	for (unsigned i = 0; i < size; i++) {
+	  READ_IF_NON_NULL(vso, g_vm->ViewShapes());
+	  ve->AddOccluder(vso);
+        }
+      }
+
+      return 0;
+    }
+
+
+    int load(istream& in, ViewVertex* vv) {
+
+      if (!vv)
+	return 1;
+
+      unsigned	tmp;
+      bool	b;
+
+      // Nature
+      Nature::VertexNature nature;
+      READ(nature);
+      vv->setNature(nature);
+      
+      if (vv->getNature() & Nature::T_VERTEX) {
+	TVertex* tv = dynamic_cast<TVertex*>(vv);
+
+	// Id
+	Id::id_type id1, id2;
+	READ(id1);
+	READ(id2);
+	tv->setId(Id(id1, id2));
+
+	// FrontSVertex
+	SVertex* fsv;
+	READ_IF_NON_NULL(fsv, g_vm->SVertices());
+	tv->setFrontVertex(fsv);
+
+	// BackSVertex
+	SVertex* bsv;
+	READ_IF_NON_NULL(bsv, g_vm->SVertices());
+	tv->setBackSVertex(bsv);
+
+	// FrontEdgeA
+	ViewEdge* fea;
+	READ_IF_NON_NULL(fea, g_vm->ViewEdges());
+	READ(b);
+	tv->setFrontEdgeA(fea, b);
+
+	// FrontEdgeB
+	ViewEdge* feb;
+	READ_IF_NON_NULL(feb, g_vm->ViewEdges());
+	READ(b);
+	tv->setFrontEdgeB(feb, b);
+
+	// BackEdgeA
+	ViewEdge* bea;
+	READ_IF_NON_NULL(bea, g_vm->ViewEdges());
+	READ(b);
+	tv->setBackEdgeA(bea, b);
+
+	// BackEdgeB
+	ViewEdge* beb;
+	READ_IF_NON_NULL(beb, g_vm->ViewEdges());
+	READ(b);
+	tv->setBackEdgeB(beb, b);
+      }
+      else if (vv->getNature() & Nature::NON_T_VERTEX) {
+	NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
+	
+	// SVertex
+	SVertex* sv;
+	READ_IF_NON_NULL(sv, g_vm->SVertices());
+	ntv->setSVertex(sv);
+	
+	// ViewEdges (List)
+	unsigned size;
+	READ(size);
+	ViewEdge* ve;
+	for (unsigned i = 0; i < size; i++) {
+	  READ_IF_NON_NULL(ve, g_vm->ViewEdges());
+	  READ(b);
+	  ntv->AddViewEdge(ve, b);
+	}
+      }
+      
+      return 0;
+    }
+
+    //////////////////// 'save' Functions ////////////////////
+
+    inline
+    int save(ostream& out, const Vec3r& v) {
+
+      if (Options::getFlags() & Options::FLOAT_VECTORS) {
+	float tmp;
+
+	tmp = v[0];
+	WRITE(tmp);
+	tmp = v[1];
+	WRITE(tmp);
+	tmp = v[2];
+	WRITE(tmp);
+      } else {
+	Vec3r::value_type tmp;
+
+	tmp = v[0];
+	WRITE(tmp);
+	tmp = v[1];
+	WRITE(tmp);
+	tmp = v[2];
+	WRITE(tmp);
+      }
+      return 0;
+    }
+
+
+    inline
+    int save(ostream& out, const Polygon3r& p) {
+
+      unsigned tmp;
+
+      // Id
+      tmp = p.getId();
+      WRITE(tmp);
+
+      // vertices (List)
+      tmp = p.getVertices().size();
+      WRITE(tmp);
+      for (vector<Vec3r>::const_iterator i = p.getVertices().begin();
+	   i != p.getVertices().end(); i++) {
+	save(out, *i);
+      }
+
+      // min & max
+      // Do not need to be saved
+
+      return 0;
+    }
+
+
+    inline
+    int save(ostream& out, const Material& m) {
+
+      unsigned i;
+      
+      // Diffuse
+      for (i = 0; i < 4; i++)
+	WRITE(m.diffuse()[i]);
+      
+      // Specular
+      for (i = 0; i < 4; i++)
+	WRITE(m.specular()[i]);
+
+      // Ambient
+      for (i = 0; i < 4; i++)
+	WRITE(m.ambient()[i]);
+      
+      // Emission
+      for (i = 0; i < 4; i++)
+	WRITE(m.emission()[i]);
+
+      // Shininess
+      float shininess = m.shininess();      
+      WRITE(shininess);
+
+      return 0;
+    }
+
+
+    int save(ostream& out, ViewShape* vs) {
+
+      if (!vs || !vs->sshape()) {
+	cerr << "Warning: null ViewShape" << endl;
+	return 1;
+      }
+
+      unsigned tmp;
+
+      // SShape
+
+      // -> Id
+      Id::id_type id = vs->sshape()->getId().getFirst();
+      WRITE(id);
+      id = vs->sshape()->getId().getSecond();
+      WRITE(id);
+
+      // -> Importance
+      float importance = vs->sshape()->importance();
+      WRITE(importance);
+
+      // -> BBox
+      //    Not necessary (only used during view map computatiom)
+
+      // -> Material
+      unsigned size = vs->sshape()->materials().size();
+      WRITE(size);
+      for(unsigned i=0; i<size; ++i)
+        save(out, vs->sshape()->material(i));
+
+      // -> VerticesList (List)
+      tmp = vs->sshape()->GetVertexList().size();
+      WRITE(tmp);
+      for (vector<SVertex*>::const_iterator i1 = vs->sshape()->GetVertexList().begin();
+	   i1 != vs->sshape()->GetVertexList().end(); i1++)
+	WRITE_IF_NON_NULL(*i1);
+
+      // -> Chains (List)
+      tmp = vs->sshape()->GetChains().size();
+      WRITE(tmp);
+      for (vector<FEdge*>::const_iterator i2 = vs->sshape()->GetChains().begin();
+	   i2 != vs->sshape()->GetChains().end(); i2++)
+	WRITE_IF_NON_NULL(*i2);
+
+      // -> EdgesList (List)
+      tmp = vs->sshape()->GetEdgeList().size();
+      WRITE(tmp);
+      for (vector<FEdge*>::const_iterator i3 = vs->sshape()->GetEdgeList().begin();
+	   i3 != vs->sshape()->GetEdgeList().end(); i3++)
+	WRITE_IF_NON_NULL(*i3);
+
+      // ViewEdges (List)
+      tmp = vs->edges().size();
+      WRITE(tmp);
+      for (vector<ViewEdge*>::const_iterator i4 = vs->edges().begin();
+	   i4 != vs->edges().end(); i4++)
+	WRITE_IF_NON_NULL(*i4);
+
+      // ViewVertices (List)
+      tmp = vs->vertices().size();
+      WRITE(tmp);
+      for (vector<ViewVertex*>::const_iterator i5 = vs->vertices().begin();
+	   i5 != vs->vertices().end(); i5++)
+	WRITE_IF_NON_NULL(*i5);
+
+      
+      return 0;
+    }
+
+
+    int save(ostream& out, FEdge* fe) {
+
+      if (!fe) {
+	cerr << "Warning: null FEdge" << endl;
+	return 1;
+      }
+
+      FEdgeSmooth * fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
+      FEdgeSharp * fesharp =  dynamic_cast<FEdgeSharp*>(fe);
+      
+      // Id
+      Id::id_type id = fe->getId().getFirst();
+      WRITE(id);
+      id = fe->getId().getSecond();
+      WRITE(id);
+
+      // Nature
+      Nature::EdgeNature nature = fe->getNature();
+      WRITE(nature);
+
+      bool b;
+
+      // hasVisibilityPoint
+      //      b = fe->hasVisibilityPoint();
+      //      WRITE(b);
+
+      // VisibilityPointA
+      //      save(out, fe->visibilityPointA());
+      //
+      //      // VisibilityPointB
+      //      save(out, fe->visibilityPointB());
+
+      unsigned index;
+      if(fe->isSmooth()){
+        // normal
+        save(out, fesmooth->normal());
+        // material
+        index = fesmooth->materialIndex();
+        WRITE(index);
+      }else{
+        // aNormal
+        save(out, fesharp->normalA());
+        // bNormal
+        save(out, fesharp->normalB());
+        // aMaterial
+        index = fesharp->aMaterialIndex();
+        WRITE(index);
+        // bMaterial
+        index = fesharp->bMaterialIndex();
+        WRITE(index);
+      }
+      
+
+      // VertexA
+      WRITE_IF_NON_NULL(fe->vertexA());
+
+      // VertexB
+      WRITE_IF_NON_NULL(fe->vertexB());
+
+      // NextEdge
+      WRITE_IF_NON_NULL(fe->nextEdge());
+
+      // PreviousEdge
+      WRITE_IF_NON_NULL(fe->previousEdge());
+
+      // ViewEdge
+      WRITE_IF_NON_NULL(fe->viewedge());
+
+      // Face
+      // Not necessary (only used during view map computatiom)
+
+      // aFace
+      save(out, (Polygon3r&)fe->aFace());
+
+      // occludeeEmpty
+      b = fe->getOccludeeEmpty();
+      WRITE(b);
+
+      // occludeeIntersection
+      save(out, fe->getOccludeeIntersection());
+
+      return 0;
+    }
+
+
+    int save(ostream& out, SVertex* sv) {
+
+      if (!sv) {
+	cerr << "Warning: null SVertex" << endl;
+	return 1;
+      }
+
+      unsigned tmp;
+
+      // Id
+      Id::id_type id = sv->getId().getFirst();
+      WRITE(id);
+      id = sv->getId().getSecond();
+      WRITE(id);
+
+      Vec3r v;
+
+      // Point3D
+      v = sv->point3D();
+      save(out, sv->point3D());
+
+      // Point2D
+      v = sv->point2D();
+      save(out, v);
+
+      // Shape
+      WRITE_IF_NON_NULL(sv->shape());
+
+      // pViewVertex
+      WRITE_IF_NON_NULL(sv->viewvertex());
+
+      // Normals (List)
+      // Note: the 'size()' method of a set doesn't seem to return the
+      // actual size of the given set, so we have to hack it...
+      set<Vec3r>::const_iterator i;
+      for (i = sv->normals().begin(), tmp = 0;
+	   i != sv->normals().end();
+	   i++, tmp++);
+      WRITE(tmp);
+      for (i = sv->normals().begin(); i != sv->normals().end(); i++)
+	save(out, *i);
+
+      // FEdges (List)
+      tmp = sv->fedges().size();
+      WRITE(tmp);
+      for (vector<FEdge*>::const_iterator j = sv->fedges_begin();
+	   j != sv->fedges_end(); j++)
+	WRITE_IF_NON_NULL(*j);
+
+      return 0;
+    }
+
+
+    int save(ostream& out, ViewEdge* ve) {
+
+      if (!ve) {
+	cerr << "Warning: null ViewEdge" << endl;
+	return 1;
+      }
+
+      unsigned tmp;
+
+      // Id
+      Id::id_type id = ve->getId().getFirst();
+      WRITE(id);
+      id = ve->getId().getSecond();
+      WRITE(id);
+
+      // Nature
+      Nature::EdgeNature nature = ve->getNature();
+      WRITE(nature);
+
+      // QI
+      unsigned qi = ve->qi();
+      WRITE(qi);
+
+      // Shape
+      WRITE_IF_NON_NULL(ve->shape());
+
+      // aShape
+      WRITE_IF_NON_NULL(ve->aShape());
+    
+      // FEdgeA
+      WRITE_IF_NON_NULL(ve->fedgeA());
+    
+      // FEdgeB
+      WRITE_IF_NON_NULL(ve->fedgeB());
+   
+      // A
+      WRITE_IF_NON_NULL(ve->A());
+
+      // B
+      WRITE_IF_NON_NULL(ve->B());
+
+      // Occluders (List)
+      if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
+        tmp = ve->occluders().size();
+        WRITE(tmp);
+        for (vector<ViewShape*>::const_iterator i = ve->occluders().begin();
+	     i != ve->occluders().end(); i++)
+          WRITE_IF_NON_NULL((*i));
+      }
+
+      return 0;
+    }
+
+
+    int save(ostream& out, ViewVertex* vv) {
+
+      if (!vv) {
+	cerr << "Warning: null ViewVertex" << endl;
+	return 1;
+      }
+
+      // Nature
+      Nature::VertexNature nature = vv->getNature();
+      WRITE(nature);
+      
+      if (vv->getNature() & Nature::T_VERTEX) {
+	TVertex* tv = dynamic_cast<TVertex*>(vv);
+	
+	// Id
+	Id::id_type id = tv->getId().getFirst();
+	WRITE(id);
+	id = tv->getId().getSecond();
+	WRITE(id);
+
+	// FrontSVertex
+	WRITE_IF_NON_NULL(tv->frontSVertex());
+	
+	// BackSVertex
+	WRITE_IF_NON_NULL(tv->backSVertex());
+	
+	// FrontEdgeA
+	WRITE_IF_NON_NULL(tv->frontEdgeA().first);
+	WRITE(tv->frontEdgeA().second);
+	
+	// FrontEdgeB
+	WRITE_IF_NON_NULL(tv->frontEdgeB().first);
+	WRITE(tv->frontEdgeB().second);
+	
+	// BackEdgeA
+	WRITE_IF_NON_NULL(tv->backEdgeA().first);
+	WRITE(tv->backEdgeA().second);
+	
+	// BackEdgeB
+	WRITE_IF_NON_NULL(tv->backEdgeB().first);
+	WRITE(tv->backEdgeB().second);
+	
+      } 
+      else if (vv->getNature() & Nature::NON_T_VERTEX) {
+	NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
+	
+	// SVertex
+	WRITE_IF_NON_NULL(ntv->svertex());
+	
+	// ViewEdges (List)
+	unsigned size = ntv->viewedges().size();
+	WRITE(size);
+        vector<ViewVertex::directedViewEdge>::const_iterator i = ntv->viewedges().begin();
+	for ( ; i != ntv->viewedges().end(); i++){
+	  WRITE_IF_NON_NULL(i->first);
+	  WRITE(i->second);
+	}
+
+      } else {
+	cerr << "Warning: unexpected ViewVertex nature" << endl;
+	return 1;
+      }
+      
+      return 0;
+    }
+
+  } // End of namespace Internal
+  
+  
+  //////////////////// "Public" 'load' and 'save' functions ////////////////////
+
+#define SET_PROGRESS(n) if (pb) pb->setProgress((n))
+
+  int load(istream& in, ViewMap* vm, ProgressBar* pb) {
+
+    if (!vm)
+      return 1;
+
+    //soc unused - unsigned tmp;
+
+    int err = 0;
+
+    Internal::g_vm = vm;
+
+    // Management of the progress bar (if present)
+    if (pb) {
+      pb->reset();
+      pb->setLabelText("Loading View Map...");
+      pb->setTotalSteps(6);
+      pb->setProgress(0);
+    }
+
+    // Read and set the options
+    unsigned char flags;
+    READ(flags);
+    Options::setFlags(flags);
+
+    // Read the size of the five ViewMap's lists (with some extra informations for the ViewVertices)
+    // and instantiate them (with default costructors)
+    unsigned vs_s, fe_s, fe_rle1, fe_rle2, sv_s, ve_s, vv_s, vv_rle1, vv_rle2;
+    READ(vs_s);
+    READ(fe_s);
+    
+    if (fe_s) {
+      bool b;
+      READ(b);
+      for (READ(fe_rle1), fe_rle2 = 0;
+      fe_rle1 < fe_s+1;
+      fe_rle2 = fe_rle1, READ(fe_rle1)) {
+        if (b) {
+          for (unsigned i = fe_rle2; i < fe_rle1; i++) {
+            FEdgeSmooth * fes = new FEdgeSmooth;
+            vm->AddFEdge(fes);
+          }
+          b = !b;
+        }
+        else if (!b) {
+          for (unsigned i = fe_rle2; i < fe_rle1; i++) {
+            FEdgeSharp * fes = new FEdgeSharp;
+            vm->AddFEdge(fes);
+          }
+          b = !b;
+        }
+      }
+    }
+
+    READ(sv_s);
+    READ(ve_s);
+    READ(vv_s);
+
+    if (vv_s) {
+      Nature::VertexNature nature;
+      READ(nature);
+      for (READ(vv_rle1), vv_rle2 = 0;
+      vv_rle1 < vv_s+1;
+      vv_rle2 = vv_rle1, READ(vv_rle1)) {
+        if (nature & Nature::T_VERTEX) {
+          for (unsigned i = vv_rle2; i < vv_rle1; i++) {
+            TVertex* tv = new TVertex();
+            vm->AddViewVertex(tv);
+          }
+          nature = Nature::NON_T_VERTEX;
+        }
+        else if (nature & Nature::NON_T_VERTEX) {
+          for (unsigned i = vv_rle2; i < vv_rle1; i++) {
+            NonTVertex* ntv = new NonTVertex();
+            vm->AddViewVertex(ntv);
+          }
+          nature = Nature::T_VERTEX;
+        }
+      }
+    }
+
+    for (unsigned i0 = 0; i0 < vs_s; i0++) {
+      SShape* ss = new SShape();
+      ViewShape* vs = new ViewShape();
+      vs->setSShape(ss);
+      ss->setViewShape(vs);
+      vm->AddViewShape(vs);
+    }
+    //    for (unsigned i1 = 0; i1 < fe_s; i1++) {
+    //      FEdge* fe = new FEdge();
+    //      vm->AddFEdge(fe);
+    //    }
+    for (unsigned i2 = 0; i2 < sv_s; i2++) {
+      SVertex* sv = new SVertex();
+      vm->AddSVertex(sv);
+    }
+    for (unsigned i3 = 0; i3 < ve_s; i3++) {
+      ViewEdge* ve = new ViewEdge();
+      vm->AddViewEdge(ve);
+    }
+
+    
+    // Read the values for all the objects created above
+    SET_PROGRESS(1);
+    for (vector<ViewShape*>::const_iterator i4 = vm->ViewShapes().begin();
+	 i4 != vm->ViewShapes().end(); i4++)
+      err += Internal::load(in, *i4);
+    SET_PROGRESS(2);
+    for (vector<FEdge*>::const_iterator i5 = vm->FEdges().begin();
+	 i5 != vm->FEdges().end(); i5++)
+      err += Internal::load(in, *i5);
+    SET_PROGRESS(3);
+    for (vector<SVertex*>::const_iterator i6 = vm->SVertices().begin();
+	 i6 != vm->SVertices().end(); i6++)
+      err += Internal::load(in, *i6);
+    SET_PROGRESS(4);
+    for (vector<ViewEdge*>::const_iterator i7 = vm->ViewEdges().begin();
+	 i7 != vm->ViewEdges().end(); i7++)
+      err += Internal::load(in, *i7);
+    SET_PROGRESS(5);
+    for (vector<ViewVertex*>::const_iterator i8 = vm->ViewVertices().begin();
+	 i8 != vm->ViewVertices().end(); i8++)
+      err += Internal::load(in, *i8);
+    SET_PROGRESS(6);
+
+    // Read the shape id to index mapping
+    unsigned map_s;
+    READ(map_s);
+    unsigned id,index;
+    for(unsigned i4=0;i4<map_s;++i4){
+        READ(id);
+        READ(index);
+        vm->shapeIdToIndexMap()[id] = index;
+    }
+    
+    return err;
+  }
+
+
+  int save(ostream& out, ViewMap* vm, ProgressBar* pb) {
+
+    if (!vm)
+      return 1;
+
+    int err = 0;
+
+    // Management of the progress bar (if present)
+    if (pb) {
+      pb->reset();
+      pb->setLabelText("Saving View Map...");
+      pb->setTotalSteps(6);
+      pb->setProgress(0);
+    }
+
+    // For every object, initialize its userdata member to its index in the ViewMap list
+    for (unsigned i0 = 0; i0 < vm->ViewShapes().size(); i0++) {
+      vm->ViewShapes()[i0]->userdata = (void*)i0;
+      vm->ViewShapes()[i0]->sshape()->userdata = (void*)i0;
+    }
+    for (unsigned i1 = 0; i1 < vm->FEdges().size(); i1++)
+      vm->FEdges()[i1]->userdata = (void*)i1;
+    for (unsigned i2 = 0; i2 < vm->SVertices().size(); i2++)
+      vm->SVertices()[i2]->userdata = (void*)i2;
+    for (unsigned i3 = 0; i3 < vm->ViewEdges().size(); i3++)
+      vm->ViewEdges()[i3]->userdata = (void*)i3;
+    for (unsigned i4 = 0; i4 < vm->ViewVertices().size(); i4++)
+      vm->ViewVertices()[i4]->userdata = (void*)i4;
+
+    // Write the current options
+    unsigned char flags = Options::getFlags();
+    WRITE(flags);
+
+    // Write the size of the five lists (with some extra informations for the ViewVertices)
+    unsigned size;
+    size = vm->ViewShapes().size();
+    WRITE(size);
+    size = vm->FEdges().size();
+    WRITE(size);
+    if (size) {
+      bool b = vm->FEdges()[0]->isSmooth();
+      WRITE(b);
+      for (unsigned i = 0; i < size; i++) {
+	while (i < size && (vm->FEdges()[i]->isSmooth() == b))
+	  i++;
+	if (i < size) {
+	  WRITE(i);
+          b = !b;
+	}
+      }
+      WRITE(size);
+      size++;
+      WRITE(size);
+    }
+    size = vm->SVertices().size();
+    WRITE(size);
+    size = vm->ViewEdges().size();
+    WRITE(size);
+    size = vm->ViewVertices().size();
+    WRITE(size);
+    if (size) {
+      Nature::VertexNature nature = vm->ViewVertices()[0]->getNature();
+      WRITE(nature);
+      nature &= ~Nature::VIEW_VERTEX;
+      for (unsigned i = 0; i < size; i++) {
+	while (i < size && (vm->ViewVertices()[i]->getNature() & nature))
+	  i++;
+	if (i < size) {
+	  WRITE(i);
+	  nature = vm->ViewVertices()[i]->getNature() & ~Nature::VIEW_VERTEX;
+	}
+      }
+      WRITE(size);
+      size++;
+      WRITE(size);
+    }
+
+
+    // Write all the elts of the ViewShapes List
+    SET_PROGRESS(1);
+    for (vector<ViewShape*>::const_iterator i5 = vm->ViewShapes().begin();
+	 i5 != vm->ViewShapes().end(); i5++)
+      err += Internal::save(out, *i5);
+    SET_PROGRESS(2);
+    for (vector<FEdge*>::const_iterator i6 = vm->FEdges().begin();
+	 i6 != vm->FEdges().end(); i6++)
+      err += Internal::save(out, *i6);
+    SET_PROGRESS(3);
+    for (vector<SVertex*>::const_iterator i7 = vm->SVertices().begin();
+	 i7 != vm->SVertices().end(); i7++)
+      err += Internal::save(out, *i7);
+    SET_PROGRESS(4);
+    for (vector<ViewEdge*>::const_iterator i8 = vm->ViewEdges().begin();
+	 i8 != vm->ViewEdges().end(); i8++)
+      err += Internal::save(out, *i8);
+    SET_PROGRESS(5);
+    for (vector<ViewVertex*>::const_iterator i9 = vm->ViewVertices().begin();
+	 i9 != vm->ViewVertices().end(); i9++)
+      err += Internal::save(out, *i9);
+
+    // Write the shape id to index mapping
+    size = vm->shapeIdToIndexMap().size();
+    WRITE(size);
+    unsigned id,index;
+    for(ViewMap::id_to_index_map::iterator mit=vm->shapeIdToIndexMap().begin(), mitend=vm->shapeIdToIndexMap().end(); mit!=mitend; ++mit){
+        id = mit->first;
+        index = mit->second;
+        WRITE(id);
+        WRITE(index);
+    }
+
+    // Reset 'userdata' members
+    for (vector<ViewShape*>::const_iterator j0 = vm->ViewShapes().begin();
+	 j0 != vm->ViewShapes().end(); j0++) {
+      (*j0)->userdata = 0;
+      (*j0)->sshape()->userdata = 0;
+    }
+    for (vector<FEdge*>::const_iterator j1 = vm->FEdges().begin();
+	 j1 != vm->FEdges().end(); j1++)
+      (*j1)->userdata = 0;
+    for (vector<SVertex*>::const_iterator j2 = vm->SVertices().begin();
+	 j2 != vm->SVertices().end(); j2++)
+      (*j2)->userdata = 0;
+    for (vector<ViewEdge*>::const_iterator j3 = vm->ViewEdges().begin();
+	 j3 != vm->ViewEdges().end(); j3++)
+      (*j3)->userdata = 0;
+    for (vector<ViewVertex*>::const_iterator j4 = vm->ViewVertices().begin();
+	 j4 != vm->ViewVertices().end(); j4++)
+      (*j4)->userdata = 0;
+    SET_PROGRESS(6);
+
+    return err;
+  }
+
+
+  //////////////////// Options ////////////////////
+
+  namespace Options {
+
+  namespace Internal {
+
+    static unsigned char g_flags = 0;
+    static string        g_models_path;
+
+  } // End of namespace Internal
+
+    void setFlags(const unsigned char flags) {
+      Internal::g_flags = flags;
+    }
+
+    void addFlags(const unsigned char flags) {
+      Internal::g_flags |= flags;
+    }
+    
+    void rmFlags(const unsigned char flags) {
+      Internal::g_flags &= ~flags;
+    }
+    
+    unsigned char getFlags() {
+      return Internal::g_flags;
+    }
+
+    void		setModelsPath(const string& path) {
+      Internal::g_models_path = path;
+    }
+
+    string		getModelsPath() {
+      return Internal::g_models_path;
+    }
+
+  }; // End of namepace Options
+
+} // End of namespace ViewMapIO
diff --git a/source/blender/freestyle/intern/view_map/ViewMapIO.h b/source/blender/freestyle/intern/view_map/ViewMapIO.h
new file mode 100755
index 00000000000..33e168b537b
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapIO.h
@@ -0,0 +1,116 @@
+//
+//  Filename         : ViewMapIO.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Functions to manage I/O for the view map
+//  Date of creation : 09/01/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAPIO_H
+# define VIEWMAPIO_H
+
+# include <fstream>
+# include <string>
+# include "../system/FreestyleConfig.h"
+# include "../system/ProgressBar.h"
+# include "ViewMap.h"
+
+namespace ViewMapIO {
+
+  static const unsigned ZERO  = UINT_MAX;
+
+  LIB_VIEW_MAP_EXPORT
+  int load(istream& in, ViewMap* vm, ProgressBar* pb = NULL);
+
+  LIB_VIEW_MAP_EXPORT
+  int save(ostream& out, ViewMap* vm, ProgressBar* pb = NULL);
+
+  namespace Options {
+    
+    static const unsigned char FLOAT_VECTORS = 1;
+    static const unsigned char NO_OCCLUDERS  = 2;
+    
+    LIB_VIEW_MAP_EXPORT
+    void		setFlags(const unsigned char flags);
+    
+    LIB_VIEW_MAP_EXPORT
+    void		addFlags(const unsigned char flags);
+
+    LIB_VIEW_MAP_EXPORT
+    void		rmFlags(const unsigned char flags);
+
+    LIB_VIEW_MAP_EXPORT
+    unsigned char	getFlags();
+    
+    LIB_VIEW_MAP_EXPORT
+    void		setModelsPath(const string& path);
+
+    LIB_VIEW_MAP_EXPORT
+    string		getModelsPath();
+
+  }; // End of namepace Options
+
+# ifdef IRIX
+  
+  namespace Internal {
+    
+    template <unsigned S>
+    ostream& write(ostream& out, const char* str) {
+      out.put(str[S - 1]);
+      return write<S - 1>(out, str);
+    }
+    
+    template<>
+    ostream& write<1>(ostream& out, const char* str) {
+      return out.put(str[0]);
+    }
+
+    template<>
+    ostream& write<0>(ostream& out, const char*) {
+      return out;
+    }
+
+    template <unsigned S>
+    istream& read(istream& in, char* str) {
+      in.get(str[S - 1]);
+      return read<S - 1>(in, str);
+    }
+    
+    template<>
+    istream& read<1>(istream& in, char* str) {
+      return in.get(str[0]);
+    }
+
+    template<>
+    istream& read<0>(istream& in, char*) {
+      return in;
+    }
+    
+  } // End of namespace Internal
+
+# endif // IRIX
+
+} // End of namespace ViewMapIO
+
+#endif // VIEWMAPIO_H
diff --git a/source/blender/freestyle/intern/view_map/ViewMapIterators.h b/source/blender/freestyle/intern/view_map/ViewMapIterators.h
new file mode 100755
index 00000000000..004674ba758
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapIterators.h
@@ -0,0 +1,542 @@
+//
+//  Filename         : ViewMapIterators.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Iterators used to iterate over the various elements
+//                     of the ViewMap
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAPITERATORS_H
+# define VIEWMAPITERATORS_H
+
+#include "ViewMap.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewMap            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewVertex         */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+namespace ViewVertexInternal{
+
+  /*! Class representing an iterator over oriented ViewEdges
+   *  around a ViewVertex. This iterator allows a CCW iteration
+   *  (in the image plane).
+   *  An instance of an orientedViewEdgeIterator can only
+   *  be obtained from a ViewVertex by calling edgesBegin() or edgesEnd().
+   */
+  class orientedViewEdgeIterator 
+  {
+  public:
+    friend class ViewVertex;
+    friend class TVertex;
+    friend class NonTVertex;
+    friend class ViewEdge;
+
+    // FIXME
+    typedef ::TVertex::edge_pointers_container edge_pointers_container;
+    typedef ::NonTVertex::edges_container edges_container;
+  protected:
+
+    Nature::VertexNature _Nature; // the nature of the underlying vertex
+    // T vertex attributes
+    edge_pointers_container::iterator _tbegin;
+    edge_pointers_container::iterator _tend;
+    edge_pointers_container::iterator _tvertex_iter;
+
+    // Non TVertex attributes
+    edges_container::iterator _begin;
+    edges_container::iterator _end;
+    edges_container::iterator _nontvertex_iter;
+
+  public:
+    /*! Default constructor */
+    inline orientedViewEdgeIterator() {}
+    inline orientedViewEdgeIterator(Nature::VertexNature iNature)
+    {_Nature = iNature;}
+    /*! Copy constructor */
+    orientedViewEdgeIterator(const orientedViewEdgeIterator& iBrother)
+    {
+      _Nature = iBrother._Nature;
+      if(_Nature & Nature::T_VERTEX)
+      {
+        _tbegin = iBrother._tbegin;
+        _tend = iBrother._tend;
+        _tvertex_iter = iBrother._tvertex_iter;
+      }
+      else
+      {
+        _begin = iBrother._begin;
+        _end = iBrother._end;
+        _nontvertex_iter = iBrother._nontvertex_iter;
+      }
+    }
+    virtual ~orientedViewEdgeIterator() {}
+ 
+  public:
+    inline orientedViewEdgeIterator(edge_pointers_container::iterator begin, 
+      edge_pointers_container::iterator end,
+      edge_pointers_container::iterator iter)
+    {
+      _Nature = Nature::T_VERTEX;
+      _tbegin = begin;
+      _tend = end;
+      _tvertex_iter = iter;
+    } 
+    inline orientedViewEdgeIterator(edges_container::iterator begin, 
+      edges_container::iterator end,
+      edges_container::iterator iter)
+    {
+      _Nature = Nature::NON_T_VERTEX;
+      _begin = begin;
+      _end = end;
+      _nontvertex_iter = iter;
+    } 
+
+  public:
+
+
+    /*! Tells whether the ViewEdge pointed
+     * by this iterator is the first one of the
+     * iteration list or not.
+     */
+    virtual bool isBegin() const 
+    {
+      if(_Nature & Nature::T_VERTEX)
+        return (_tvertex_iter == _tbegin);
+      else
+        return (_nontvertex_iter == _begin);
+    }
+    /*! Tells whether the ViewEdge pointed
+     * by this iterator is after the last one of the
+     * iteration list or not.
+     */
+    virtual bool isEnd() const 
+    {
+      if(_Nature & Nature::T_VERTEX)
+        return (_tvertex_iter == _tend);
+      else
+        return (_nontvertex_iter == _end);
+    }
+
+    // operators
+    /*! Increments.In the scripting language, call
+     *  "increment()".
+     */
+    virtual orientedViewEdgeIterator& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    /*! Increments.In the scripting language, call
+     *  "increment()".
+     */
+    virtual orientedViewEdgeIterator operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      orientedViewEdgeIterator tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    } 
+  
+    // comparibility
+    /*! operator != */
+    virtual bool operator!=(const orientedViewEdgeIterator& b) const
+    {
+      if(_Nature & Nature::T_VERTEX)
+        return (_tvertex_iter != b._tvertex_iter);
+      else
+        return (_nontvertex_iter != b._nontvertex_iter);
+    }
+
+    /*! operator == */
+    virtual bool operator==(const orientedViewEdgeIterator& b) const
+    {return !(*this != b);}
+    
+    // dereferencing
+    /*! Returns a reference to the pointed orientedViewEdge.
+     *  In the scripting language, you must call
+     *  "getObject()"instead.
+     */
+    virtual ::ViewVertex::directedViewEdge& operator*() const
+    {
+      if(_Nature & Nature::T_VERTEX)
+        //return _tvertex_iter;
+        return **_tvertex_iter;
+      else
+        return (*_nontvertex_iter);
+    }
+    /*! Returns a pointer to the pointed orientedViewEdge.
+     * Can't be called in the scripting language.
+     */
+    virtual ::ViewVertex::directedViewEdge* operator->() const { return &(operator*());}
+
+  public:
+    /*! increments.*/
+    inline void increment()
+    {
+      if(_Nature & Nature::T_VERTEX)
+      { 
+        ::ViewVertex::directedViewEdge tmp = (**_tvertex_iter);
+        ++_tvertex_iter;
+        if(_tvertex_iter != _tend){
+          // FIXME : pquoi deja ?
+          ::ViewVertex::directedViewEdge tmp2 = (**_tvertex_iter);
+          if(tmp2.first == tmp.first)
+            ++_tvertex_iter;
+        }
+      }
+      else
+        ++_nontvertex_iter;
+    }
+  };
+
+  }
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             ViewEdge           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+namespace ViewEdgeInternal {
+//
+// SVertexIterator
+//
+/////////////////////////////////////////////////
+
+  class SVertexIterator : public Interface0DIteratorNested
+  {
+  public:
+
+    SVertexIterator() {
+      _vertex = NULL;
+      _begin = NULL;
+      _previous_edge = NULL;
+      _next_edge = NULL;
+      _t = 0;
+    }
+
+    SVertexIterator(const SVertexIterator& vi) {
+      _vertex = vi._vertex;
+      _begin = vi._begin;
+      _previous_edge = vi._previous_edge;
+      _next_edge = vi._next_edge;
+      _t = vi._t;
+    }
+
+    SVertexIterator(SVertex* v, SVertex* begin, FEdge* prev, FEdge* next, float t) {
+      _vertex = v;
+      _begin = begin;
+      _previous_edge = prev;
+      _next_edge = next;
+      _t = t;
+    }
+
+    SVertexIterator& operator=(const SVertexIterator& vi) {
+      _vertex = vi._vertex;
+      _begin = vi._begin;
+      _previous_edge = vi._previous_edge;
+      _next_edge = vi._next_edge;
+      _t = vi._t;
+      return *this;
+    }
+
+    virtual ~SVertexIterator() {}
+
+    virtual string getExactTypeName() const {
+      return "SVertexIterator";
+    }
+
+    virtual SVertex& operator*() {
+      return *_vertex;
+    }
+
+    virtual SVertex* operator->() {
+      return &(operator*());
+    }
+
+    virtual SVertexIterator& operator++() {
+      increment();
+      return *this;
+    }
+
+    virtual SVertexIterator operator++(int) {
+      SVertexIterator ret(*this);
+      increment();
+      return ret;
+    }
+
+    virtual SVertexIterator& operator--() {
+      decrement();
+      return *this;
+    }
+
+    virtual SVertexIterator operator--(int) {
+      SVertexIterator ret(*this);
+      decrement();
+      return ret;
+    }
+
+    virtual void increment(){
+      if (!_next_edge) {
+	      _vertex = 0;
+	    return;
+      }
+      _t += (float)_next_edge->getLength2D();
+      _vertex = _next_edge->vertexB();
+      _previous_edge = _next_edge;
+      _next_edge = _next_edge->nextEdge();
+      
+    }
+    virtual void decrement(){
+      if (!_previous_edge) {
+	      _vertex = 0;
+	    return;
+      }
+      if((!_next_edge) && (!_vertex)){
+        _vertex = _previous_edge->vertexB();
+        return;
+      }
+      _t -= (float)_previous_edge->getLength2D();
+      _vertex = _previous_edge->vertexA();
+      _next_edge = _previous_edge;
+      _previous_edge = _previous_edge->previousEdge();
+  } 
+
+    bool isBegin() const {
+      return _vertex == _begin;
+    }
+
+    bool isEnd() const {
+      return (!_vertex) || (_vertex == _begin && _previous_edge);
+    }
+
+    virtual float t() const {
+      return _t;
+    }
+    virtual float u() const {
+      return _t/(float)_next_edge->viewedge()->getLength2D();
+    }
+
+    virtual bool operator==(const Interface0DIteratorNested& it) const {
+      const SVertexIterator* it_exact = dynamic_cast<const SVertexIterator*>(&it);
+      if (!it_exact)
+	return false;
+      return (_vertex == it_exact->_vertex);
+    }
+
+    virtual SVertexIterator* copy() const {
+      return new SVertexIterator(*this);
+    }
+
+  private:
+
+    SVertex*	_vertex;
+    SVertex*	_begin;
+    FEdge*	_previous_edge;
+    FEdge*	_next_edge;
+    float _t; // curvilinear abscissa
+  };
+
+
+
+//
+// ViewEdgeIterator (base class)
+//
+///////////////////////////////////////////////////////////
+
+  /*! Base class for iterators over ViewEdges of the ViewMap Graph.
+   *  Basically the "increment()" operator of this class should
+   *  be able to take the decision of "where" (on which ViewEdge) to go
+   *  when pointing on a given ViewEdge.
+   *  ::Caution::: the dereferencing operator returns a *pointer* to
+   *  the pointed ViewEdge.
+   */
+class ViewEdgeIterator
+{
+public:
+
+  /*! Builds a ViewEdgeIterator from a starting ViewEdge and its orientation.
+   *  \param begin
+   *    The ViewEdge from where to start the iteration.
+   *  \param orientation
+   *    If true, we'll look for the next ViewEdge among the
+   *    ViewEdges that surround the ending ViewVertex of begin.
+   *    If false, we'll search over the ViewEdges surrounding
+   *    the ending ViewVertex of begin.
+   */
+  ViewEdgeIterator(ViewEdge* begin = 0, bool orientation = true) {
+    _orientation = orientation;
+    _edge = begin;
+    _begin = begin;
+  }
+
+  /*! Copy constructor */
+  ViewEdgeIterator(const ViewEdgeIterator& it) {
+    _orientation = it._orientation;
+    _edge = it._edge;
+    _begin = it._begin;
+  }
+
+  virtual ~ViewEdgeIterator() {}
+
+  /*! Returns the string "ViewEdgeIterator" */
+  virtual string getExactTypeName() const {
+    return "ViewEdgeIterator";
+  }
+
+  /*! Returns the current pointed ViewEdge. */
+  ViewEdge* getCurrentEdge() {
+    return _edge;
+  }
+
+  /*! Sets the current pointed ViewEdge. */
+  void setCurrentEdge(ViewEdge* edge) {
+    _edge = edge;
+  }
+
+  /*! Returns the first ViewEdge used for the iteration. */
+  ViewEdge* getBegin() {
+    return _begin;
+  }
+
+  /*! Sets the first ViewEdge used for the iteration. */
+  void setBegin(ViewEdge* begin) {
+    _begin = begin;
+  }
+
+  /*! Gets the orientation of the pointed ViewEdge in the iteration. */
+  bool getOrientation() const {
+    return _orientation;
+  }
+
+  /*! Sets the orientation of the pointed ViewEdge in the iteration. */
+  void setOrientation(bool orientation) {
+    _orientation = orientation;
+  }
+
+  /*! Changes the current orientation. */
+  void changeOrientation() {
+    _orientation = !_orientation;
+  }
+
+  /*! Returns a *pointer* to the pointed ViewEdge. */
+  virtual ViewEdge* operator*() {
+    return _edge;
+  }
+
+  virtual ViewEdge* operator->() {
+    return operator*();
+  }
+
+  /*! Increments. In the scripting language, call
+   *  "increment()".
+   */
+  virtual ViewEdgeIterator& operator++() {
+    increment();
+    return *this;
+  }
+
+  /*! Increments. In the scripting language, call
+   *  "increment()".
+   */
+  virtual ViewEdgeIterator operator++(int) {
+    ViewEdgeIterator tmp(*this);
+    increment();
+    return tmp;
+  }
+
+  /*! increments. */
+  virtual void increment() {
+    cerr << "Warning: method increment() not implemented" << endl;
+  }
+
+  /*! Decrements. In the scripting language, call
+   *  "decrement()".
+   */
+  virtual ViewEdgeIterator& operator--() {
+    decrement();
+    return *this;
+  }
+
+  /*! Decrements. In the scripting language, call
+   *  "decrement()".
+   */
+  virtual ViewEdgeIterator operator--(int) {
+    ViewEdgeIterator tmp(*this);
+    decrement();
+    return tmp;
+  }
+
+  /*! decrements. */
+  virtual void decrement(){
+    cerr << "Warning: method decrement() not implemented" << endl;
+  }
+
+  /*! Returns true if the pointed ViewEdge is the
+   * first one used for the iteration.
+   */
+  virtual bool isBegin() const {
+    return _edge == _begin;
+  }
+
+  /*! Returns true if the pointed ViewEdge* equals 0. 
+   */
+  virtual bool isEnd() const {
+    return !_edge;
+  }
+
+  /*! operator == */
+  virtual bool operator==(ViewEdgeIterator& it) const {
+    return _edge == it._edge;
+  }
+
+  /*! operator != */
+  virtual bool operator!=(ViewEdgeIterator& it) const {
+    return !(*this == it);
+  }
+
+protected:
+
+  bool		_orientation;
+  ViewEdge*	_edge;
+  ViewEdge*	_begin;
+};
+
+} // end of namespace ViewEdgeInternal
+
+#endif // VIEWMAPITERATORS_H
+
diff --git a/source/blender/freestyle/intern/view_map/ViewMapTesselator.cpp b/source/blender/freestyle/intern/view_map/ViewMapTesselator.cpp
new file mode 100755
index 00000000000..6041f527d17
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapTesselator.cpp
@@ -0,0 +1,36 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ViewMapTesselator.h"
+
+NodeGroup* ViewMapTesselator::Tesselate(ViewMap *iViewMap)
+{
+  if(0 == iViewMap->ViewEdges().size())
+    return NULL;
+
+  const vector<ViewEdge*>& viewedges = iViewMap->ViewEdges();
+  return Tesselate(viewedges.begin(), viewedges.end());
+}
+
+NodeGroup* ViewMapTesselator::Tesselate(WShape *)
+{
+  return NULL;
+}
diff --git a/source/blender/freestyle/intern/view_map/ViewMapTesselator.h b/source/blender/freestyle/intern/view_map/ViewMapTesselator.h
new file mode 100755
index 00000000000..2d054d8a067
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMapTesselator.h
@@ -0,0 +1,196 @@
+//
+//  Filename         : ViewMapTesselator.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to build a Node Tree designed to be displayed 
+//                     from a Silhouette View Map structure.
+//  Date of creation : 26/03/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  VIEWMAPTESSELATOR_H
+# define VIEWMAPTESSELATOR_H
+
+# include "../scene_graph/NodeShape.h"
+# include "../winged_edge/WEdge.h"
+# include "Silhouette.h"
+# include "ViewMap.h"
+# include "../scene_graph/NodeGroup.h"
+# include "../scene_graph/LineRep.h"
+# include "../scene_graph/OrientedLineRep.h"
+# include "../scene_graph/VertexRep.h"
+
+class NodeShape;
+class NodeGroup;
+class SShape;
+class WShape;
+
+class LIB_VIEW_MAP_EXPORT ViewMapTesselator
+{
+public:
+
+  inline ViewMapTesselator() {_nature = Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE;_Material.setDiffuse(0,0,0,1);_overloadMaterial=false;}
+  virtual ~ViewMapTesselator() {}
+
+  /*! Builds a set of lines rep contained under a 
+   *  a NodeShape, itself contained under a NodeGroup from a ViewMap
+   */
+  NodeGroup* Tesselate(ViewMap* iViewMap) ;
+
+  /*! Builds a set of lines rep contained under a 
+   *  a NodeShape, itself contained under a NodeGroup from a 
+   *  set of view edges
+   */
+  template<class ViewEdgesIterator>
+  NodeGroup* Tesselate(ViewEdgesIterator begin, ViewEdgesIterator end) ;
+
+  /*! Builds a set of lines rep contained among a 
+   *  a NodeShape, from a WShape
+   */
+  NodeGroup* Tesselate(WShape* iWShape);
+
+  
+  inline void setNature(Nature::EdgeNature iNature) {_nature = iNature;}
+  inline void setMaterial(const Material& iMaterial) {_Material=iMaterial;_overloadMaterial=true;}
+  inline Nature::EdgeNature nature() {return _nature;}
+  inline const Material& material() const {return _Material;}
+
+protected:
+  virtual void AddVertexToLine(LineRep *iLine, SVertex *v) = 0;
+  
+private:
+  Nature::EdgeNature _nature;
+  Material _Material;
+  bool _overloadMaterial;
+};
+
+/*! Class to tesselate the 2D projected silhouette */
+class ViewMapTesselator2D : public ViewMapTesselator
+{
+public:
+  inline ViewMapTesselator2D() : ViewMapTesselator() {}
+  virtual ~ViewMapTesselator2D() {}
+
+protected:
+  virtual void AddVertexToLine(LineRep *iLine, SVertex *v)
+  {
+    iLine->AddVertex(v->point2D());
+  }
+};
+
+/*! Class to tesselate the 3D silhouette */
+class ViewMapTesselator3D : public ViewMapTesselator
+{
+public:
+  inline ViewMapTesselator3D() : ViewMapTesselator() {}
+  virtual ~ViewMapTesselator3D() {}
+
+protected:
+  virtual void AddVertexToLine(LineRep *iLine, SVertex *v)
+  {
+    iLine->AddVertex(v->point3D());
+  }
+};
+
+//
+// Implementation
+//
+///////////////////////////////////////////////
+
+template<class ViewEdgesIterator>
+NodeGroup * ViewMapTesselator::Tesselate(ViewEdgesIterator begin, ViewEdgesIterator end) 
+{
+  NodeGroup *group = new NodeGroup;
+  NodeShape *tshape = new NodeShape;
+  group->AddChild(tshape);
+  //tshape->material().setDiffuse(0.f, 0.f, 0.f, 1.f);
+  tshape->setMaterial(_Material);
+
+  LineRep* line;
+
+
+  FEdge *firstEdge;
+  FEdge *nextFEdge, *currentEdge;
+  
+  int id=0;
+  //  for(vector<ViewEdge*>::const_iterator c=viewedges.begin(),cend=viewedges.end();
+  //      c!=cend;
+  //      c++)
+  for(ViewEdgesIterator c=begin, cend=end;
+  c!=cend;
+  c++)
+    {
+    //    if((*c)->qi() > 0){
+    //      continue;
+    //    }
+        //      if(!((*c)->nature() & (_nature)))
+        //        continue;
+        //      
+      firstEdge = (*c)->fedgeA(); 
+
+      //      if(firstEdge->invisibility() > 0)
+      //        continue;
+      
+      line = new OrientedLineRep();
+      if(_overloadMaterial)
+        line->setMaterial(_Material);
+
+      // there might be chains containing a single element
+      if(0 == (firstEdge)->nextEdge())
+      {
+        line->setStyle(LineRep::LINES);
+        // line->AddVertex((*c)->vertexA()->point3D());
+        // line->AddVertex((*c)->vertexB()->point3D());
+        AddVertexToLine(line, firstEdge->vertexA());
+        AddVertexToLine(line, firstEdge->vertexB());
+      }
+      else
+      {
+        line->setStyle(LineRep::LINE_STRIP);
+
+        //firstEdge = (*c);
+        nextFEdge = firstEdge;
+        currentEdge = firstEdge;
+        do
+        {
+          //line->AddVertex(nextFEdge->vertexA()->point3D());
+          AddVertexToLine(line, nextFEdge->vertexA());
+           currentEdge = nextFEdge;
+           nextFEdge = nextFEdge->nextEdge();
+         }while((nextFEdge != NULL) && (nextFEdge != firstEdge));
+        // Add the last vertex
+        //line->AddVertex(currentEdge->vertexB()->point3D());
+        AddVertexToLine(line, currentEdge->vertexB());
+                
+      }
+
+      line->setId((*c)->getId().getFirst());
+      line->ComputeBBox();
+      tshape->AddRep(line);
+      id++;
+    }
+  
+  return group;
+}
+
+#endif // VIEWMAPTESSELATOR_H
diff --git a/source/blender/freestyle/intern/view_map/src.pri b/source/blender/freestyle/intern/view_map/src.pri
new file mode 100755
index 00000000000..2faf6a81fea
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/src.pri
@@ -0,0 +1,34 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+VIEW_MAP_DIR = ../view_map
+
+SOURCES *= $${VIEW_MAP_DIR}/Functions0D.cpp \
+           $${VIEW_MAP_DIR}/Functions1D.cpp \
+	   $${VIEW_MAP_DIR}/Silhouette.cpp \
+	   $${VIEW_MAP_DIR}/SilhouetteGeomEngine.cpp \
+	   $${VIEW_MAP_DIR}/ViewMap.cpp \
+	   $${VIEW_MAP_DIR}/ViewMapBuilder.cpp \
+	   $${VIEW_MAP_DIR}/ViewMapIO.cpp \
+	   $${VIEW_MAP_DIR}/ViewMapTesselator.cpp \
+	   $${VIEW_MAP_DIR}/FEdgeXDetector.cpp \
+       $${VIEW_MAP_DIR}/ViewEdgeXBuilder.cpp \
+       $${VIEW_MAP_DIR}/SteerableViewMap.cpp 
+
+HEADERS *= $${VIEW_MAP_DIR}/Functions0D.h \
+           $${VIEW_MAP_DIR}/Functions1D.h \
+           $${VIEW_MAP_DIR}/Interface0D.h \
+           $${VIEW_MAP_DIR}/Interface1D.h \
+	   $${VIEW_MAP_DIR}/Silhouette.h \
+	   $${VIEW_MAP_DIR}/SilhouetteGeomEngine.h \
+	   $${VIEW_MAP_DIR}/ViewMap.h \
+           $${VIEW_MAP_DIR}/ViewMapAdvancedIterators.h \
+	   $${VIEW_MAP_DIR}/ViewMapBuilder.h \
+	   $${VIEW_MAP_DIR}/ViewMapIO.h \
+           $${VIEW_MAP_DIR}/ViewMapIterators.h \
+	   $${VIEW_MAP_DIR}/ViewMapTesselator.h \
+	   $${VIEW_MAP_DIR}/FEdgeXDetector.h \
+       $${VIEW_MAP_DIR}/ViewEdgeXBuilder.h \
+       $${VIEW_MAP_DIR}/SteerableViewMap.h 
diff --git a/source/blender/freestyle/intern/view_map/view_map.pro b/source/blender/freestyle/intern/view_map/view_map.pro
new file mode 100755
index 00000000000..ef629bcf6a7
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/view_map.pro
@@ -0,0 +1,89 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_VIEW_MAP}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES   *= MAKE_LIB_VIEW_MAP_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../geometry ../image ../scene_graph ../system ../winged_edge
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# LIBS
+#
+#######################################
+
+win32:LIBS      *= $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_IMAGE}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SCENE_GRAPH}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_WINGED_EDGE}$${LIBVERSION}.lib
+
+!win32 {
+  lib_bundle {
+    LIBS += -F$${DESTDIR} -framework $${LIB_GEOMETRY} \
+	    -framework $${LIB_IMAGE} -framework $${LIB_SCENE_GRAPH} \
+                   -framework $${LIB_SYSTEM} -framework $${LIB_WINGED_EDGE}
+  } else {
+    LIBS *= -L$${DESTDIR} -l$${LIB_GEOMETRY} -l$${LIB_IMAGE} -l$${LIB_SCENE_GRAPH} \
+                   -l$${LIB_SYSTEM} -l$${LIB_WINGED_EDGE}
+  }
+}
+
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/intern/winged_edge/Curvature.cpp b/source/blender/freestyle/intern/winged_edge/Curvature.cpp
new file mode 100755
index 00000000000..a890fb92c04
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/Curvature.cpp
@@ -0,0 +1,647 @@
+/* GTS - Library for the manipulation of triangulated surfaces
+ * Copyright (C) 1999-2002 Ray Jones, Stéphane Popinet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "Curvature.h"
+#include <math.h>
+#include "WEdge.h"
+#include "../system/FreestyleConfig.h"
+#include "../geometry/normal_cycle.h"
+#include <set>
+#include <stack>
+
+static bool angle_obtuse (WVertex * v, WFace * f)
+{
+  WOEdge * e; 
+  f->getOppositeEdge (v, e);
+  
+  Vec3r vec1(e->GetaVertex()->GetVertex()-v->GetVertex());
+  Vec3r vec2(e->GetbVertex()->GetVertex()-v->GetVertex());
+  return ((vec1 * vec2) < 0);
+}
+
+// FIXME
+// WVvertex is useless but kept for history reasons
+static bool triangle_obtuse (WVertex*, WFace * f)
+{
+  bool b=false;
+  for (int i=0; i<3; i++)
+    b = b ||
+      ((f->GetEdgeList()[i]->getVec3r() * f->GetEdgeList()[(i+1)%3]->getVec3r()) < 0);
+  return b;
+}
+
+static real cotan (WVertex * vo, WVertex * v1, WVertex * v2)
+{
+  /* cf. Appendix B of [Meyer et al 2002] */
+  real udotv, denom;
+
+  Vec3r u(v1->GetVertex()- vo->GetVertex());
+  Vec3r v(v2->GetVertex()- vo->GetVertex());
+
+  udotv = u * v;
+  denom = sqrt(u.squareNorm() * v.squareNorm() - udotv * udotv);
+
+  /* denom can be zero if u==v.  Returning 0 is acceptable, based on
+   * the callers of this function below. */
+  if (denom == 0.0) return (0.0);
+
+  return (udotv / denom);
+}
+
+static real angle_from_cotan (WVertex * vo, WVertex * v1, WVertex * v2)
+{
+  /* cf. Appendix B and the caption of Table 1 from [Meyer et al 2002] */
+  real udotv, denom;
+
+  Vec3r u (v1->GetVertex()-vo->GetVertex());
+  Vec3r v(v2->GetVertex()-vo->GetVertex());
+
+  udotv = u * v;
+  denom = sqrt(u.squareNorm() * v.squareNorm() - udotv * udotv);
+
+  /* Note: I assume this is what they mean by using atan2 (). -Ray Jones */
+
+  /* tan = denom/udotv = y/x (see man page for atan2) */
+  return (fabs (atan2 (denom, udotv)));
+}
+
+/** 
+ * gts_vertex_mean_curvature_normal:
+ * @v: a #WVertex.  
+ * @s: a #GtsSurface.
+ * @Kh: the Mean Curvature Normal at @v.
+ *
+ * Computes the Discrete Mean Curvature Normal approximation at @v.
+ * The mean curvature at @v is half the magnitude of the vector @Kh.
+ *
+ * Note: the normal computed is not unit length, and may point either
+ * into or out of the surface, depending on the curvature at @v.  It
+ * is the responsibility of the caller of the function to use the mean
+ * curvature normal appropriately.
+ *
+ * This approximation is from the paper:
+ * Discrete Differential-Geometry Operators for Triangulated 2-Manifolds
+ * Mark Meyer, Mathieu Desbrun, Peter Schroder, Alan H. Barr
+ * VisMath '02, Berlin (Germany) 
+ * http://www-grail.usc.edu/pubs.html
+ *
+ * Returns: %TRUE if the operator could be evaluated, %FALSE if the
+ * evaluation failed for some reason (@v is boundary or is the
+ * endpoint of a non-manifold edge.)
+ */
+bool gts_vertex_mean_curvature_normal (WVertex * v, Vec3r &Kh)
+{
+	real area = 0.0;
+
+	if (!v) return false;
+
+	/* this operator is not defined for boundary edges */
+	if (v->isBoundary()) return false;
+    
+	WVertex::incoming_edge_iterator itE;
+
+	for (itE=v->incoming_edges_begin();
+	     itE!=v->incoming_edges_end(); itE++)
+			 area+=(*itE)->GetaFace()->getArea();
+
+	Kh=Vec3r(0.0, 0.0, 0.0);
+
+	for (itE=v->incoming_edges_begin();
+	     itE!=v->incoming_edges_end(); itE++)
+		{
+			WOEdge * e = (*itE)->getPrevOnFace();
+			//if ((e->GetaVertex()==v) || (e->GetbVertex()==v)) cerr<< "BUG ";
+
+			WVertex * v1 = e->GetaVertex();
+			WVertex * v2 = e->GetbVertex();
+			real temp;
+
+			temp = cotan (v1, v, v2);
+			Kh = Vec3r(Kh+temp*(v2->GetVertex()-v->GetVertex()));
+
+			temp = cotan (v2, v, v1);
+			Kh = Vec3r(Kh+temp*(v1->GetVertex()-v->GetVertex()));
+		}
+	if (area > 0.0) 
+	{
+		Kh[0] /= 2*area;
+		Kh[1] /= 2*area;
+		Kh[2] /= 2*area;
+	} 
+	else return false;
+
+	return true;
+}
+
+/** 
+ * gts_vertex_gaussian_curvature:
+ * @v: a #WVertex.  
+ * @s: a #GtsSurface.
+ * @Kg: the Discrete Gaussian Curvature approximation at @v.
+ *
+ * Computes the Discrete Gaussian Curvature approximation at @v.
+ *
+ * This approximation is from the paper:
+ * Discrete Differential-Geometry Operators for Triangulated 2-Manifolds
+ * Mark Meyer, Mathieu Desbrun, Peter Schroder, Alan H. Barr
+ * VisMath '02, Berlin (Germany) 
+ * http://www-grail.usc.edu/pubs.html
+ *
+ * Returns: %TRUE if the operator could be evaluated, %FALSE if the
+ * evaluation failed for some reason (@v is boundary or is the
+ * endpoint of a non-manifold edge.)
+ */
+bool gts_vertex_gaussian_curvature (WVertex * v,  real * Kg)
+{
+	real area = 0.0;
+	real angle_sum = 0.0;
+
+	if (!v) return false; 
+	if (!Kg) return false; 
+
+ 	/* this operator is not defined for boundary edges */
+	if (v->isBoundary()) {*Kg=0.0 ;return false;}
+    
+	WVertex::incoming_edge_iterator itE;
+	for (itE=v->incoming_edges_begin();
+	     itE!=v->incoming_edges_end(); itE++)
+			 area+=(*itE)->GetaFace()->getArea();
+
+ 	for (itE=v->incoming_edges_begin();
+	     itE!=v->incoming_edges_end(); itE++)
+		{
+			WOEdge * e = (*itE)->getPrevOnFace();
+			WVertex * v1 = e->GetaVertex();
+			WVertex * v2 = e->GetbVertex(); 
+			angle_sum += angle_from_cotan (v, v1, v2);
+		}
+ 
+	*Kg = (2.0*M_PI - angle_sum)/area;
+
+	return true;
+}
+
+/** 
+ * gts_vertex_principal_curvatures:
+ * @Kh: mean curvature.
+ * @Kg: Gaussian curvature.
+ * @K1: first principal curvature.
+ * @K2: second principal curvature.
+ *
+ * Computes the principal curvatures at a point given the mean and
+ * Gaussian curvatures at that point.  
+ *
+ * The mean curvature can be computed as one-half the magnitude of the
+ * vector computed by gts_vertex_mean_curvature_normal().
+ *
+ * The Gaussian curvature can be computed with
+ * gts_vertex_gaussian_curvature().
+ */
+void gts_vertex_principal_curvatures (real Kh, real Kg, 
+				      real * K1, real * K2)
+{
+  real temp = Kh*Kh - Kg;
+
+  if (!K1) return; 
+  if (!K1) return; 
+
+  if (temp < 0.0) temp = 0.0;
+  temp = sqrt (temp);
+  *K1 = Kh + temp;
+  *K2 = Kh - temp;
+}
+
+/* from Maple */
+static void linsolve (real m11, real m12, real b1,
+		      real m21, real m22, real b2,
+		      real * x1, real * x2)
+{
+  real temp;
+
+  temp = 1.0 / (m21*m12 - m11*m22);
+  *x1 = (m12*b2 - m22*b1)*temp;
+  *x2 = (m11*b2 - m21*b1)*temp;
+}
+                
+/* from Maple - largest eigenvector of [a b; b c] */
+static void eigenvector (real a, real b, real c,
+			 Vec3r e)
+{
+  if (b == 0.0) {
+    e[0] = 0.0;
+  } else {
+    e[0] = -(c - a - sqrt (c*c - 2*a*c + a*a + 4*b*b))/(2*b);
+  }
+  e[1] = 1.0;
+  e[2] = 0.0;
+}
+
+/** 
+ * gts_vertex_principal_directions:
+ * @v: a #WVertex.  
+ * @s: a #GtsSurface.
+ * @Kh: mean curvature normal (a #Vec3r).
+ * @Kg: Gaussian curvature (a real).
+ * @e1: first principal curvature direction (direction of largest curvature).
+ * @e2: second principal curvature direction.
+ *
+ * Computes the principal curvature directions at a point given @Kh
+ * and @Kg, the mean curvature normal and Gaussian curvatures at that
+ * point, computed with gts_vertex_mean_curvature_normal() and
+ * gts_vertex_gaussian_curvature(), respectively. 
+ *
+ * Note that this computation is very approximate and tends to be
+ * unstable.  Smoothing of the surface or the principal directions may
+ * be necessary to achieve reasonable results.  
+ */
+void gts_vertex_principal_directions (WVertex * v, 
+                                      Vec3r Kh, real Kg,
+									  Vec3r &e1, Vec3r &e2)
+{
+  Vec3r N;
+  real normKh;
+
+  Vec3r basis1, basis2, d, eig;
+  real ve2, vdotN;
+  real aterm_da, bterm_da, cterm_da, const_da;
+  real aterm_db, bterm_db, cterm_db, const_db;
+  real a, b, c;
+  real K1, K2;
+  real *weights, *kappas, *d1s, *d2s;
+  int edge_count;
+  real err_e1, err_e2;
+  int e;
+  WVertex::incoming_edge_iterator itE;
+
+  /* compute unit normal */
+  normKh = Kh.norm();
+
+  if (normKh > 0.0) {
+    Kh.normalize();
+  } else {
+    /* This vertex is a point of zero mean curvature (flat or saddle
+     * point).  Compute a normal by averaging the adjacent triangles
+     */
+    N[0] = N[1] = N[2] = 0.0;
+
+    for (itE=v->incoming_edges_begin();
+	 itE!=v->incoming_edges_end(); itE++)
+      N=Vec3r(N+(*itE)->GetaFace()->GetNormal());
+    real normN = N.norm();
+    if (normN <= 0.0)
+      return;
+    N.normalize();
+  }
+    
+
+  /* construct a basis from N: */
+  /* set basis1 to any component not the largest of N */
+  basis1[0] =  basis1[1] =  basis1[2] = 0.0;
+  if (fabs (N[0]) > fabs (N[1]))
+    basis1[1] = 1.0;
+  else
+    basis1[0] = 1.0;
+    
+  /* make basis2 orthogonal to N */
+  basis2 = (N ^ basis1);
+  basis2.normalize();
+
+  /* make basis1 orthogonal to N and basis2 */
+  basis1 = (N ^ basis2);
+  basis1.normalize();
+  
+  aterm_da = bterm_da = cterm_da = const_da = 0.0;
+  aterm_db = bterm_db = cterm_db = const_db = 0.0;
+  int nb_edges=v->GetEdges().size();
+
+  weights = (real *) malloc (sizeof (real)*nb_edges);
+  kappas = (real*) malloc (sizeof (real)*nb_edges);
+  d1s = (real*) malloc (sizeof (real)*nb_edges);
+  d2s = (real*) malloc (sizeof (real)*nb_edges);
+  edge_count = 0;
+
+  for (itE=v->incoming_edges_begin();
+	   itE!=v->incoming_edges_end(); itE++)
+	   {
+			WOEdge * e;
+			WFace * f1, * f2;
+			real weight, kappa, d1, d2;
+			Vec3r vec_edge;
+			if (! *itE) continue;
+			e = *itE;
+
+			/* since this vertex passed the tests in
+			* gts_vertex_mean_curvature_normal(), this should be true. */
+			//g_assert (gts_edge_face_number (e, s) == 2);
+
+			/* identify the two triangles bordering e in s */
+			f1=e->GetaFace();
+			f2=e->GetbFace();
+
+    /* We are solving for the values of the curvature tensor 
+     *     B = [ a b ; b c ].  
+     * The computations here are from section 5 of [Meyer et al 2002].  
+     *
+     * The first step is to calculate the linear equations governing
+     * the values of (a,b,c).  These can be computed by setting the
+     * derivatives of the error E to zero (section 5.3).
+     * 
+     * Since a + c = norm(Kh), we only compute the linear equations
+     * for dE/da and dE/db.  (NB: [Meyer et al 2002] has the
+     * equation a + b = norm(Kh), but I'm almost positive this is
+     * incorrect.)
+     *
+     * Note that the w_ij (defined in section 5.2) are all scaled by
+     * (1/8*A_mixed).  We drop this uniform scale factor because the
+     * solution of the linear equations doesn't rely on it.
+     *
+     * The terms of the linear equations are xterm_dy with x in
+     * {a,b,c} and y in {a,b}.  There are also const_dy terms that are
+     * the constant factors in the equations.  
+     */
+
+    /* find the vector from v along edge e */
+    vec_edge=Vec3r(-1*e->getVec3r());
+
+    ve2 = vec_edge.squareNorm();
+    vdotN = vec_edge * N;
+
+    /* section 5.2 - There is a typo in the computation of kappa.  The
+     * edges should be x_j-x_i.
+     */
+    kappa = 2.0 * vdotN / ve2;
+
+    /* section 5.2 */
+
+    /* I don't like performing a minimization where some of the
+     * weights can be negative (as can be the case if f1 or f2 are
+     * obtuse).  To ensure all-positive weights, we check for
+     * obtuseness. */
+    weight = 0.0;
+    if (! triangle_obtuse(v, f1)) {
+      weight += ve2 * 
+        cotan (f1->GetNextOEdge(e->twin())->GetbVertex(), 
+               e->GetaVertex(), e->GetbVertex()) / 8.0;
+    } else {
+      if (angle_obtuse (v, f1)) {
+        weight += ve2 * f1->getArea() / 4.0;
+      } else {
+        weight += ve2 * f1->getArea() / 8.0;
+      }
+    }
+
+    if (! triangle_obtuse(v, f2)) {
+      weight += ve2 * 
+        cotan (f2->GetNextOEdge(e)->GetbVertex(), 
+              e->GetaVertex(), e->GetbVertex()) / 8.0;
+    } else {
+      if (angle_obtuse (v, f2)) {
+        weight += ve2 * f1->getArea() / 4.0;
+      } else {
+        weight += ve2 * f1->getArea()  / 8.0;
+      }
+    }
+
+    /* projection of edge perpendicular to N (section 5.3) */
+    d[0] = vec_edge[0] - vdotN * N[0];
+    d[1] = vec_edge[1] - vdotN * N[1];
+    d[2] = vec_edge[2] - vdotN * N[2];
+    d.normalize();
+    
+    /* not explicit in the paper, but necessary.  Move d to 2D basis. */
+    d1 = d * basis1;
+    d2 = d * basis2;
+
+    /* store off the curvature, direction of edge, and weights for later use */
+    weights[edge_count] = weight;
+    kappas[edge_count] = kappa;
+    d1s[edge_count] = d1;
+    d2s[edge_count] = d2;
+    edge_count++;
+
+    /* Finally, update the linear equations */
+    aterm_da += weight * d1 * d1 * d1 * d1;
+    bterm_da += weight * d1 * d1 * 2 * d1 * d2;
+    cterm_da += weight * d1 * d1 * d2 * d2;
+    const_da += weight * d1 * d1 * (- kappa);
+
+    aterm_db += weight * d1 * d2 * d1 * d1;
+    bterm_db += weight * d1 * d2 * 2 * d1 * d2;
+    cterm_db += weight * d1 * d2 * d2 * d2;
+    const_db += weight * d1 * d2 * (- kappa);
+
+   }
+
+  /* now use the identity (Section 5.3) a + c = |Kh| = 2 * kappa_h */
+  aterm_da -= cterm_da;
+  const_da += cterm_da * normKh;
+
+  aterm_db -= cterm_db;
+  const_db += cterm_db * normKh;
+  
+  /* check for solvability of the linear system */
+  if (((aterm_da * bterm_db - aterm_db * bterm_da) != 0.0) &&
+      ((const_da != 0.0) || (const_db != 0.0))) {
+    linsolve (aterm_da, bterm_da, -const_da,
+              aterm_db, bterm_db, -const_db,
+              &a, &b);
+
+    c = normKh - a;
+
+    eigenvector (a, b, c, eig);
+  } else {
+    /* region of v is planar */
+    eig[0] = 1.0;
+    eig[1] = 0.0;
+  }
+
+  /* Although the eigenvectors of B are good estimates of the
+   * principal directions, it seems that which one is attached to
+   * which curvature direction is a bit arbitrary.  This may be a bug
+   * in my implementation, or just a side-effect of the inaccuracy of
+   * B due to the discrete nature of the sampling.
+   *
+   * To overcome this behavior, we'll evaluate which assignment best
+   * matches the given eigenvectors by comparing the curvature
+   * estimates computed above and the curvatures calculated from the
+   * discrete differential operators.  */
+
+  gts_vertex_principal_curvatures (0.5 * normKh, Kg, &K1, &K2);
+  
+  err_e1 = err_e2 = 0.0;
+  /* loop through the values previously saved */
+  for (e = 0; e < edge_count; e++) {
+    real weight, kappa, d1, d2;
+    real temp1, temp2;
+    real delta;
+
+    weight = weights[e];
+    kappa = kappas[e];
+    d1 = d1s[e];
+    d2 = d2s[e];
+
+    temp1 = fabs (eig[0] * d1 + eig[1] * d2);
+    temp1 = temp1 * temp1;
+    temp2 = fabs (eig[1] * d1 - eig[0] * d2);
+    temp2 = temp2 * temp2;
+
+    /* err_e1 is for K1 associated with e1 */
+    delta = K1 * temp1 + K2 * temp2 - kappa;
+    err_e1 += weight * delta * delta;
+
+    /* err_e2 is for K1 associated with e2 */
+    delta = K2 * temp1 + K1 * temp2 - kappa;
+    err_e2 += weight * delta * delta;
+  }
+  free (weights);
+  free (kappas);
+  free (d1s);
+  free (d2s);
+
+  /* rotate eig by a right angle if that would decrease the error */
+  if (err_e2 < err_e1) {
+    real temp = eig[0];
+
+    eig[0] = eig[1];
+    eig[1] = -temp;
+  }
+
+  e1[0] = eig[0] * basis1[0] + eig[1] * basis2[0];
+  e1[1] = eig[0] * basis1[1] + eig[1] * basis2[1];
+  e1[2] = eig[0] * basis1[2] + eig[1] * basis2[2];
+  e1.normalize();
+
+  /* make N,e1,e2 a right handed coordinate sytem */
+  e2 =  N ^ e1;
+  e2.normalize();
+}
+
+namespace OGF {
+    static real angle(WOEdge* h) {
+        Vec3r e(h->GetbVertex()->GetVertex()-h->GetaVertex()->GetVertex()) ;
+        Vec3r n1 = h->GetbFace()->GetNormal();
+        Vec3r n2 = h->GetaFace()->GetNormal();
+        real sine = (n1 ^ n2) * e / e.norm() ;
+        if(sine >= 1.0) {
+            return M_PI / 2.0 ;
+        }
+        if(sine <= -1.0) {
+            return -M_PI / 2.0 ;
+        }
+        return ::asin(sine) ;
+    }
+
+    // precondition1: P is inside the sphere
+    // precondition2: P,V points to the outside of 
+    //   the sphere (i.e. OP.V > 0)
+    static bool sphere_clip_vector(
+        const Vec3r& O, real r,
+        const Vec3r& P, Vec3r& V
+    ) {
+
+        Vec3r W = P - O ;
+        real a = V.squareNorm() ;
+        real b = 2.0 * V * W ;
+        real c = W.squareNorm() - r*r ;
+        real delta = b*b - 4*a*c ;
+        if(delta < 0) {
+            // Should not happen, but happens sometimes (numerical precision)
+            return true ;
+        }
+        real t = - b + ::sqrt(delta) / (2.0 * a) ;
+        if(t < 0.0) {
+            // Should not happen, but happens sometimes (numerical precision)
+            return true ;
+        }
+        if(t >= 1.0) {
+            // Inside the sphere
+            return false ;
+        }
+
+        V[0] = (t * V.x()) ;
+        V[1] = (t * V.y()) ;
+        V[2] = (t * V.z()) ;
+
+        return true ;
+    }
+
+    // TODO: check optimizations:
+    // use marking ? (measure *timings* ...)
+    void compute_curvature_tensor(
+        WVertex* start, real radius, NormalCycle& nc
+    ) {
+        // in case we have a non-manifold vertex, skip it...
+        if(start->isBoundary())
+          return;
+      
+        std::set<WVertex*> vertices ;
+        const Vec3r& O = start->GetVertex() ;
+        std::stack<WVertex*> S ;
+        S.push(start) ;
+        vertices.insert(start) ;
+        while(!S.empty()) {
+            WVertex* v = S.top() ;
+            S.pop() ;
+            if(v->isBoundary())
+              continue;
+            const Vec3r& P = v->GetVertex() ;
+            WVertex::incoming_edge_iterator woeit = v->incoming_edges_begin();
+            WVertex::incoming_edge_iterator woeitend = v->incoming_edges_end();
+            for(;woeit!=woeitend; ++woeit){
+              WOEdge *h = *woeit;
+              Vec3r V(h->GetaVertex()->GetVertex()-h->GetbVertex()->GetVertex()) ;
+              if((v == start) || V * (P - O) > 0.0) {
+                    bool isect = sphere_clip_vector(O, radius, P, V) ;
+                    if(h->GetOwner()->GetNumberOfOEdges() == 2) {
+                        real beta = angle(h) ;
+                        nc.accumulate_dihedral_angle(V, beta) ;
+                    }
+                    if(!isect) {
+                        WVertex* w = h->GetaVertex() ;
+                        if(vertices.find(w) == vertices.end()) {
+                            vertices.insert(w) ;
+                            S.push(w) ;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    void compute_curvature_tensor_one_ring(
+        WVertex* start, NormalCycle& nc
+    ) {
+        // in case we have a non-manifold vertex, skip it...
+        if(start->isBoundary())
+          return;
+      
+        WVertex::incoming_edge_iterator woeit = start->incoming_edges_begin();
+        WVertex::incoming_edge_iterator woeitend = start->incoming_edges_end();
+        for(;woeit!=woeitend; ++woeit){
+          WOEdge *h = (*woeit)->twin();
+          Vec3r hvec(h->GetbVertex()->GetVertex()-h->GetaVertex()->GetVertex());
+          nc.accumulate_dihedral_angle(hvec, angle(h)) ;
+          WOEdge *hprev = h->getPrevOnFace();
+          Vec3r hprevvec(hprev->GetbVertex()->GetVertex()-hprev->GetaVertex()->GetVertex());
+          nc.accumulate_dihedral_angle(hprevvec, angle(hprev)) ;
+        }
+    }
+
+}
diff --git a/source/blender/freestyle/intern/winged_edge/Curvature.h b/source/blender/freestyle/intern/winged_edge/Curvature.h
new file mode 100755
index 00000000000..214a32ca922
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/Curvature.h
@@ -0,0 +1,156 @@
+
+/* GTS - Library for the manipulation of triangulated surfaces
+ * Copyright (C) 1999 Stéphane Popinet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __CURVATURE_H__
+#define __CURVATURE_H__
+
+# include "../system/FreestyleConfig.h"
+# include "../system/Precision.h"
+# include "../geometry/Geom.h"
+using namespace Geometry;
+
+class WVertex;
+
+class LIB_WINGED_EDGE_EXPORT CurvatureInfo
+{
+public:
+
+  CurvatureInfo()
+  {
+    K1 = 0.0;
+    K2 = 0.0;
+    e1 = Vec3r(0.0,0.0,0.0);
+    e2 = Vec3r(0.0,0.0,0.0);
+    Kr = 0.0;
+    dKr = 0.0;
+    er = Vec3r(0.0,0.0,0.0);
+  }
+
+  CurvatureInfo(const CurvatureInfo& iBrother){
+    K1 = iBrother.K1;
+    K2 = iBrother.K2;
+    e1 = iBrother.e1;
+    e2 = iBrother.e2;
+    Kr = iBrother.Kr;
+    dKr = iBrother.dKr;
+    er = iBrother.er;
+  }
+
+  CurvatureInfo(const CurvatureInfo& ca, const CurvatureInfo& cb, real t) {
+    K1 = ca.K1 + t * (cb.K1 - ca.K1);
+    K2 = ca.K2 + t * (cb.K2 - ca.K2);
+    e1 = ca.e1 + t * (cb.e1 - ca.e1);
+    e2 = ca.e2 + t * (cb.e2 - ca.e2);
+    Kr = ca.Kr + t * (cb.Kr - ca.Kr);
+    dKr = ca.dKr + t * (cb.dKr - ca.dKr);
+    er = ca.er + t * (cb.er - ca.er);
+  }
+
+  real K1; // maximum curvature
+  real K2; // minimum curvature
+  Vec3r e1; // maximum curvature direction
+  Vec3r e2; // minimum curvature direction
+  real Kr; // radial curvature
+  real dKr; // radial curvature
+  Vec3r er; // radial curvature direction
+};
+
+class Face_Curvature_Info{
+public:
+  Face_Curvature_Info() {}
+  ~Face_Curvature_Info(){
+    for(vector<CurvatureInfo*>::iterator ci=vec_curvature_info.begin(), ciend=vec_curvature_info.end();
+    ci!=ciend;
+    ++ci){
+      delete (*ci);
+    }
+    vec_curvature_info.clear();
+  }
+  vector<CurvatureInfo *> vec_curvature_info;
+};
+
+bool LIB_WINGED_EDGE_EXPORT gts_vertex_mean_curvature_normal  (WVertex * v, 
+					Vec3r &n);
+
+bool LIB_WINGED_EDGE_EXPORT gts_vertex_gaussian_curvature     (WVertex * v, 
+					real * Kg);
+
+void LIB_WINGED_EDGE_EXPORT gts_vertex_principal_curvatures   (real Kh, 
+					real Kg, 
+					real * K1, 
+					real * K2);
+
+void LIB_WINGED_EDGE_EXPORT gts_vertex_principal_directions   (WVertex * v, 
+					Vec3r Kh,
+					real Kg,
+					Vec3r &e1, 
+					Vec3r &e2);
+
+/*
+ *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
+ *  Copyright (C) 2000-2003 Bruno Levy
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  If you modify this software, you should include a notice giving the
+ *  name of the person performing the modification, the date of modification,
+ *  and the reason for such modification.
+ *
+ *  Contact: Bruno Levy
+ *
+ *     levy@loria.fr
+ *
+ *     ISA Project
+ *     LORIA, INRIA Lorraine, 
+ *     Campus Scientifique, BP 239
+ *     54506 VANDOEUVRE LES NANCY CEDEX 
+ *     FRANCE
+ *
+ *  Note that the GNU General Public License does not permit incorporating
+ *  the Software into proprietary programs. 
+ */
+ namespace OGF {
+
+    class NormalCycle ;
+
+    void LIB_WINGED_EDGE_EXPORT compute_curvature_tensor(
+            WVertex* start, double radius, NormalCycle& nc
+        ) ;
+
+    void LIB_WINGED_EDGE_EXPORT compute_curvature_tensor_one_ring(
+            WVertex* start, NormalCycle& nc
+        ) ;
+ }
+
+
+#endif /* __CURVATURE_H__ */
+
diff --git a/source/blender/freestyle/intern/winged_edge/Nature.h b/source/blender/freestyle/intern/winged_edge/Nature.h
new file mode 100755
index 00000000000..1f165e677f5
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/Nature.h
@@ -0,0 +1,75 @@
+//
+//  Filename         : Nature.h
+//  Author(s)        : Emmanuel Turquin
+//  Purpose          : Different natures for both vertices and edges
+//  Date of creation : 01/07/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  NATURE_H
+# define NATURE_H
+
+/*! \file Nature.h
+ *  Definitions of Natures of the ViewMap's elements
+ */
+
+/*! Namespace gathering the different possible 
+ *  natures of 0D and 1D elements of the ViewMap
+ */
+namespace Nature {
+  
+  typedef unsigned short VertexNature;
+
+  /*! true for any 0D element */
+  static const VertexNature POINT		= 0;		// 0
+  /*! true for SVertex */
+  static const VertexNature S_VERTEX		= (1 << 0);	// 1
+  /*! true for ViewVertex */
+  static const VertexNature VIEW_VERTEX		= (1 << 1);	// 2
+  /*! true for NonTVertex */
+  static const VertexNature NON_T_VERTEX	= (1 << 2);	// 4
+  /*! true for TVertex */
+  static const VertexNature T_VERTEX		= (1 << 3);	// 8
+  /*! true for CUSP */
+  static const VertexNature CUSP		= (1 << 4);	// 16
+
+  typedef unsigned short EdgeNature;
+  /*! true for non feature edges (always false for 1D elements of the ViewMap) */
+  static const EdgeNature NO_FEATURE		= 0;		// 0
+  /*! true for silhouettes */
+  static const EdgeNature SILHOUETTE		= (1 << 0);	// 1
+  /*! true for borders */
+  static const EdgeNature BORDER		= (1 << 1);	// 2
+  /*! true for creases */
+  static const EdgeNature CREASE		= (1 << 2);	// 4
+  /*! true for ridges */
+  static const EdgeNature RIDGE			= (1 << 3);	// 8
+  /*! true for valleys */
+  static const EdgeNature VALLEY		= (1 << 4);	// 16
+  /*! true for suggestive contours */
+  static const EdgeNature SUGGESTIVE_CONTOUR	= (1 << 5);	// 32
+
+} // end of namespace Nature
+
+#endif // NATURE_H
diff --git a/source/blender/freestyle/intern/winged_edge/WEdge.cpp b/source/blender/freestyle/intern/winged_edge/WEdge.cpp
new file mode 100755
index 00000000000..0d02e0ca131
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WEdge.cpp
@@ -0,0 +1,732 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <iostream>
+#include "WEdge.h"
+
+/*! Temporary structures */
+class vertexdata
+{
+public:
+  WVertex *_copy;
+};
+
+class oedgedata
+{
+public:
+  WOEdge *_copy;
+};
+
+class edgedata
+{
+public:
+  WEdge *_copy;
+};
+
+class facedata
+{
+public:
+  WFace *_copy;
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+WVertex::WVertex(WVertex& iBrother)
+{
+  _Id = iBrother._Id;
+  _Vertex = iBrother._Vertex;
+  _EdgeList = iBrother._EdgeList;
+
+  _Shape = iBrother._Shape;
+  _Smooth = iBrother._Smooth;
+  _Border = iBrother._Border;
+  userdata = NULL;
+  iBrother.userdata = new vertexdata;
+  ((vertexdata*)(iBrother.userdata))->_copy = this;
+}
+
+WVertex* WVertex::duplicate()
+{
+  WVertex *clone = new WVertex(*this);
+  return clone;
+}
+
+
+WOEdge* WVertex::incoming_edge_iterator::operator*()
+
+{ 
+      return _current;
+}
+void WVertex::incoming_edge_iterator::increment(){
+  WOEdge *twin = _current->twin();
+  if(!twin){
+    // we reached a hole
+    _current = 0;
+    return;
+  }
+  WOEdge *next = twin->getPrevOnFace();
+  if(next == _begin){
+    next = 0;
+  }
+  _current = next;
+}
+
+WFace* WVertex::face_iterator::operator*(){
+  WOEdge * woedge = *_edge_it;
+  if(woedge == 0)
+    return 0;
+  return (woedge)->GetbFace();
+}
+
+//bool WVertex::isBoundary () const{
+// return _Border;
+//}
+bool WVertex::isBoundary ()
+{
+    if(_Border == 1)
+        return true;
+    else if(_Border == 0)
+        return false;
+    
+	vector<WEdge *>::const_iterator it;
+    for(it=_EdgeList.begin(); it!=_EdgeList.end(); it++){
+        if((*it)->GetNumberOfOEdges() == 1){
+            _Border = 1;
+            return true;
+        }
+    }
+		//if (!(*it)->GetaOEdge()->GetaFace()) return true;
+    _Border = 0;
+	return false;
+}
+
+void WVertex::AddEdge(WEdge *iEdge) {
+  _EdgeList.push_back(iEdge);
+}
+
+WVertex::incoming_edge_iterator WVertex::incoming_edges_begin(){
+  WOEdge *begin;
+  WEdge * wedge = _EdgeList.front();
+  WOEdge* aOEdge = wedge->GetaOEdge();
+  if(aOEdge->GetbVertex() == this)
+    begin = aOEdge;
+  else
+    begin = _EdgeList.front()->GetbOEdge();
+  return incoming_edge_iterator(this, begin, begin);
+}
+WVertex::incoming_edge_iterator WVertex::incoming_edges_end(){
+  WOEdge *begin;
+  WOEdge* aOEdge = _EdgeList.front()->GetaOEdge();
+  if(aOEdge->GetbVertex() == this)
+    begin = aOEdge;
+  else
+    begin = _EdgeList.front()->GetbOEdge();
+  return incoming_edge_iterator(this, begin, 0);
+}
+//WOEdge** WVertex::incoming_edge_iterator::operator->()
+//{ 
+//      WOEdge ** ppaOEdge = (*_iter)->GetaOEdge();
+//      if(aOEdge->GetbVertex() == _vertex)
+//       return ppaOEdge;
+//      else
+//      {
+//        WOEdge *bOEdge = (*_iter)->GetbOEdge();
+//        return &bOEdge;
+//      }
+//       
+//}
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WOEdge             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+WOEdge::WOEdge(WOEdge& iBrother)
+{
+    _paVertex = iBrother.GetaVertex();
+    _pbVertex = iBrother.GetbVertex();
+    _paFace = iBrother.GetaFace();
+    _pbFace = iBrother.GetbFace();
+    _pOwner = iBrother.GetOwner();
+    userdata = NULL;
+    iBrother.userdata = new oedgedata;
+    ((oedgedata*)(iBrother.userdata))->_copy = this;
+}
+
+WOEdge * WOEdge::duplicate()
+{
+  WOEdge *clone = new WOEdge(*this);
+  return clone;
+}
+
+Vec3r 
+WOEdge::getVec3r ()
+{
+   return Vec3r(_pbVertex->GetVertex() - _paVertex->GetVertex());
+} 
+
+WOEdge * WOEdge::twin ()
+{
+	 return GetOwner()->GetOtherOEdge(this);
+}
+
+WOEdge * 
+WOEdge::getPrevOnFace()
+{
+	return _pbFace->GetPrevOEdge(this);
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WEdge              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+WEdge::WEdge(WEdge& iBrother)
+{
+  _paOEdge = NULL;
+  _pbOEdge = NULL;
+  WOEdge *aoedge = iBrother.GetaOEdge();
+  WOEdge *boedge = iBrother.GetbOEdge();
+  userdata = NULL;
+
+  if(NULL != aoedge)
+    //_paOEdge = new WOEdge(*aoedge);
+    _paOEdge = aoedge->duplicate();
+  if(NULL != boedge)
+    //_pbOEdge = new WOEdge(*boedge);
+    _pbOEdge = boedge->duplicate();
+  
+  _nOEdges = iBrother.GetNumberOfOEdges();
+  _Id = iBrother.GetId();
+  iBrother.userdata = new edgedata;
+  ((edgedata*)(iBrother.userdata))->_copy = this;
+}
+
+WEdge * WEdge::duplicate()
+{
+  WEdge *clone = new WEdge(*this);
+  return clone;
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WFace              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+WFace::WFace(WFace& iBrother)
+{
+  _OEdgeList = iBrother.GetEdgeList();
+  _Normal = iBrother.GetNormal();
+  _VerticesNormals = iBrother._VerticesNormals;
+  _VerticesTexCoords = iBrother._VerticesTexCoords;
+  _Id = iBrother.GetId();
+  _MaterialIndex = iBrother._MaterialIndex;
+  userdata = NULL;
+  iBrother.userdata = new facedata;
+  ((facedata*)(iBrother.userdata))->_copy = this;
+}
+
+WFace * WFace::duplicate()
+{
+  WFace * clone = new WFace(*this);
+  return clone;
+}
+
+const Material& WFace::material() {
+  return getShape()->material(_MaterialIndex);
+}
+
+WOEdge * WFace::MakeEdge(WVertex *v1, WVertex *v2)
+{
+  // First check whether the same oriented edge already exists 
+  // or not:
+  vector<WEdge *>& v1Edges = v1->GetEdges();
+  for(vector<WEdge*>::iterator it1=v1Edges.begin(), end=v1Edges.end(); 
+  it1!=end; 
+  it1++)
+  {
+
+    WEdge *we=(*it1);
+
+    WOEdge *woea = we->GetaOEdge();
+
+    if((woea->GetaVertex() == v1) && (woea->GetbVertex() == v2))
+    //if((*it1)->GetbVertex() == v2)
+    {
+      // The oriented edge already exists
+      cerr << "Warning: edge " << v1->GetId() << " - " << v2->GetId() << " appears twice, correcting" << endl;
+      // Adds the edge to the face
+      //AddEdge((*it1)->GetaOEdge());
+      AddEdge(woea);
+      (*it1)->setNumberOfOEdges((*it1)->GetNumberOfOEdges()+1);
+      //sets these vertices as border:
+      v1->setBorder(true);
+      v2->setBorder(true);
+      //return (*it1)->GetaOEdge();
+      return woea;
+    }
+
+    WOEdge *woeb = we->GetbOEdge();
+    if((woeb != 0) && (woeb->GetaVertex() == v1) && (woeb->GetbVertex() == v2))
+
+    //if((*it1)->GetbVertex() == v2)
+
+    {
+      // The oriented edge already exists
+      cerr << "Warning: edge " << v1->GetId() << " - " << v2->GetId() << " appears twice, correcting" << endl;
+      // Adds the edge to the face
+      //AddEdge((*it1)->GetaOEdge());
+      AddEdge(woeb);
+      (*it1)->setNumberOfOEdges((*it1)->GetNumberOfOEdges()+1);
+      //sets these vertices as border:
+      v1->setBorder(true);
+      v2->setBorder(true);
+      //return (*it1)->GetaOEdge();
+      return woeb;
+    }
+  }
+  
+  // the oriented edge we're about to build
+  WOEdge *pOEdge = new WOEdge;
+  
+  WEdge * edge; // The edge containing the oriented edge.
+  
+  // checks whether this edge already exists or not
+  // If it exists, it points outward v2
+
+  bool exist = false;
+  WOEdge *pInvertEdge = NULL; // The inverted edge if it exists
+  vector<WEdge *>& v2Edges = v2->GetEdges();
+  vector<WEdge *>::iterator it;
+  for(it=v2Edges.begin(); it!=v2Edges.end(); it++)
+  {
+    if((*it)->GetbVertex() == v1)
+    {
+      // The invert edge already exists
+      exist = true;
+      pInvertEdge = (*it)->GetaOEdge();
+      break;
+    }
+  }
+
+  //DEBUG:
+  
+
+  if(true == exist) // The invert edge already exists
+  {
+    // Retrieves the corresponding edge
+    edge = pInvertEdge->GetOwner(); 
+    
+    // Sets the a Face (retrieved from pInvertEdge
+    pOEdge->setaFace(pInvertEdge->GetbFace());
+    
+    // Updates the invert edge:
+    pInvertEdge->setaFace(this);
+  }
+  else // The invert edge does not exist yet
+  {
+    // we must create a new edge
+    //edge = new WEdge;
+    edge = instanciateEdge();
+    
+    // updates the a,b vertex edges list:
+    v1->AddEdge(edge);
+    v2->AddEdge(edge);
+
+  }
+
+  pOEdge->setOwner(edge);
+  // Add the vertices:
+  pOEdge->setaVertex(v1);
+  pOEdge->setbVertex(v2);
+
+  // Debug:
+  if(v1->GetId() == v2->GetId())
+    cerr << "Warning: edge " << this << " null with vertex " << v1->GetId() << endl;
+
+  edge->AddOEdge(pOEdge);
+  //edge->setNumberOfOEdges(edge->GetNumberOfOEdges()+1);
+
+  // Add this face (the b face)
+  pOEdge->setbFace(this);
+
+  // Adds the edge to the face
+  AddEdge(pOEdge);
+
+  return pOEdge;
+}
+
+
+bool 
+WFace::getOppositeEdge (const WVertex *v, WOEdge* &e)
+{
+	if (_OEdgeList.size()!=3) return false;
+
+	vector<WOEdge *>::iterator it;
+	e=NULL;
+	for(it=_OEdgeList.begin(); it!=_OEdgeList.end(); it++)
+		if ((*it)->GetaVertex()==v) e=*it;
+	if (!e) return false; 
+	e=NULL;
+	for(it=_OEdgeList.begin(); it!=_OEdgeList.end(); it++)
+		if (((*it)->GetaVertex()!=v) && ((*it)->GetbVertex()!=v)) e=*it;
+	if (!e) return false; 
+	else return true;
+}
+
+real
+WFace::getArea ()
+{
+	vector<WOEdge *>::iterator it;
+	Vec3r origin=(*(_OEdgeList.begin()))->GetaVertex()->GetVertex();
+	it=_OEdgeList.begin();
+	real a=0;
+	for (it=it++; it!=_OEdgeList.end(); it++) {
+	  Vec3r v1=Vec3r((*it)->GetaVertex()->GetVertex() - origin);		
+	  Vec3r v2=Vec3r((*it)->GetbVertex()->GetVertex() - origin);	
+	  a += (v1 ^ v2).norm() / 2.0;
+	}
+	return a;
+}
+
+
+WOEdge* 
+WFace::GetPrevOEdge(WOEdge* iOEdge)
+  {
+    vector<WOEdge*>::iterator woe,woend, woefirst;
+    woefirst = _OEdgeList.begin();
+	woend=_OEdgeList.end();
+	WOEdge *prev =*woefirst;
+    woe=woefirst;
+	woe++;
+    for(;
+        woe!=woend;
+        woe++)
+	{
+        if((*woe) == iOEdge)
+            return prev;
+		prev= *woe;
+	}
+    // We left the loop. That means that the first
+    // OEdge was the good one:
+    if((*woefirst)==iOEdge)
+      return prev;
+
+    return NULL;
+  }
+
+WShape * WFace::getShape()
+{
+  return GetVertex(0)->shape();
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WShape             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+LIB_WINGED_EDGE_EXPORT
+unsigned WShape::_SceneCurrentId = 0;
+
+WShape * WShape::duplicate()
+{
+  WShape *clone = new WShape(*this);
+  return clone;
+}
+
+WShape::WShape(WShape& iBrother)
+{
+  _Id = iBrother.GetId();
+  _Materials = iBrother._Materials;
+  _meanEdgeSize = iBrother._meanEdgeSize;
+  iBrother.bbox(_min, _max);
+  vector<WVertex*>& vertexList = iBrother.GetVertexList();
+  vector<WVertex*>::iterator v=vertexList.begin(), vend=vertexList.end();
+  for(;
+  v!=vend;
+  v++)
+  {
+    //WVertex *newVertex = new WVertex(*(*v));
+    WVertex *newVertex = (*v)->duplicate();
+
+    newVertex->setShape(this);
+    AddVertex(newVertex);
+  }
+
+  vector<WEdge*>& edgeList = iBrother.GetEdgeList();
+  vector<WEdge*>::iterator e=edgeList.begin(), eend=edgeList.end();
+  for(;
+  e!=eend;
+  e++)
+  {
+    //WEdge *newEdge = new WEdge(*(*e));
+    WEdge *newEdge = (*e)->duplicate();
+    AddEdge(newEdge);
+  }
+
+  vector<WFace*>& faceList = iBrother.GetFaceList();
+  vector<WFace*>::iterator f=faceList.begin(), fend=faceList.end();
+  for(;
+  f!=fend;
+  f++)
+  {
+    //WFace *newFace = new WFace(*(*f));
+    WFace *newFace = (*f)->duplicate();
+    AddFace(newFace);
+  }
+
+  // update all pointed addresses thanks to the newly created objects:
+  vend=_VertexList.end();
+  for(v=_VertexList.begin();
+  v!=vend;
+  v++)
+  {
+    const vector<WEdge*>& vedgeList = (*v)->GetEdges();
+    vector<WEdge*> newvedgelist;
+    unsigned int i;
+    for(i=0; i<vedgeList.size(); i++)
+    {
+      WEdge *current = vedgeList[i];
+      edgedata * currentvedata = (edgedata*)current->userdata;
+      newvedgelist.push_back(currentvedata->_copy);
+    }
+    (*v)->setEdges(newvedgelist);
+  }
+
+  eend = _EdgeList.end();
+  for(e=_EdgeList.begin();
+  e!=eend;
+  e++)
+  {
+    // update aOedge:
+    WOEdge *aoEdge = (*e)->GetaOEdge();
+    aoEdge->setaVertex(((vertexdata*)(aoEdge->GetaVertex()->userdata))->_copy);
+    aoEdge->setbVertex(((vertexdata*)(aoEdge->GetbVertex()->userdata))->_copy);
+    if(NULL != aoEdge->GetaFace())
+      aoEdge->setaFace(((facedata*)(aoEdge->GetaFace()->userdata))->_copy);
+    aoEdge->setbFace(((facedata*)(aoEdge->GetbFace()->userdata))->_copy);
+    aoEdge->setOwner(((edgedata*)(aoEdge->GetOwner()->userdata))->_copy);
+    // update bOedge:
+
+    WOEdge *boEdge = (*e)->GetbOEdge();
+    if(boEdge != 0)
+    {
+      boEdge->setaVertex(((vertexdata*)(boEdge->GetaVertex()->userdata))->_copy);
+      boEdge->setbVertex(((vertexdata*)(boEdge->GetbVertex()->userdata))->_copy);
+      if(NULL != boEdge->GetaFace())
+        boEdge->setaFace(((facedata*)(boEdge->GetaFace()->userdata))->_copy);
+      boEdge->setbFace(((facedata*)(boEdge->GetbFace()->userdata))->_copy);
+      boEdge->setOwner(((edgedata*)(boEdge->GetOwner()->userdata))->_copy);
+    }
+  }
+
+  fend = _FaceList.end();
+  for(f=_FaceList.begin();
+  f!=fend;
+  f++)
+  {
+    unsigned i;
+    const vector<WOEdge*>& oedgeList = (*f)->GetEdgeList();
+    vector<WOEdge*> newoedgelist;
+
+    unsigned n = oedgeList.size();
+    for(i=0; i<n; i++)
+    {
+      WOEdge *current = oedgeList[i];
+      oedgedata * currentoedata = (oedgedata*)current->userdata;
+      newoedgelist.push_back(currentoedata->_copy);
+      //oedgeList[i] = currentoedata->_copy;
+      //oedgeList[i] = ((oedgedata*)(oedgeList[i]->userdata))->_copy;
+    }
+    (*f)->setEdgeList(newoedgelist);
+  }
+
+  // Free all memory (arghh!)
+  // Vertex
+  vend = iBrother.GetVertexList().end();
+  for(v=iBrother.GetVertexList().begin();
+  v!=vend;
+  v++)
+  {
+    delete (vertexdata*)((*v)->userdata);
+    (*v)->userdata = NULL;
+  }
+
+  // Edges and OEdges:
+  eend = iBrother.GetEdgeList().end();
+  for(e=iBrother.GetEdgeList().begin();
+  e!=eend;
+  e++)
+  {
+    delete (edgedata*)((*e)->userdata);
+    (*e)->userdata = NULL;
+    // OEdge a :
+    delete (oedgedata*)((*e)->GetaOEdge()->userdata);
+    (*e)->GetaOEdge()->userdata = NULL;
+    // OEdge b:
+    WOEdge* oedgeb = (*e)->GetbOEdge();
+    if(NULL != oedgeb)
+    {
+      delete (oedgedata*)(oedgeb->userdata);
+      oedgeb->userdata = NULL;
+    }
+  }
+  // Faces
+  fend = iBrother.GetFaceList().end();
+  for(f=iBrother.GetFaceList().begin();
+  f!=fend;
+  f++)
+  {
+    delete (facedata*)((*f)->userdata);
+    (*f)->userdata = NULL;
+  }
+}
+
+WFace* WShape::MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterial)
+{
+  // allocate the new face
+  WFace *face = instanciateFace();
+
+  return MakeFace(iVertexList, iMaterial, face);
+}
+
+WFace * WShape::MakeFace(vector<WVertex*>& iVertexList, vector<Vec3r>& iNormalsList, vector<Vec2r>& iTexCoordsList, unsigned iMaterial)
+{
+  // allocate the new face
+  WFace *face = MakeFace(iVertexList, iMaterial);
+
+  if(0 == face)
+
+    return 0;
+
+  // set the list of per-vertex normals
+  face->setNormalList(iNormalsList);
+  // set the list of per-vertex tex coords
+  face->setTexCoordsList(iTexCoordsList);
+
+  return face;
+}
+
+WFace* WShape::MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterial, WFace *face)
+{
+
+  int id = _FaceList.size();
+
+  face->setMaterialIndex(iMaterial);
+
+  // Check whether we have a degenerated face:
+
+  // LET'S HACK IT FOR THE TRIANGLE CASE:
+
+  if(3 == iVertexList.size())
+
+  {
+
+    if((iVertexList[0] == iVertexList[1]) 
+
+      || (iVertexList[0] == iVertexList[2]) 
+
+      || (iVertexList[2] == iVertexList[1]))
+
+    {
+
+      cerr << "Warning: degenerated triangle detected, correcting" << endl;
+      return 0;
+
+    }
+
+  }
+  // vertex pointers used to build each edge
+  vector<WVertex*>::iterator va, vb, it;
+
+  va = iVertexList.begin();
+  vb = va;
+  for(; va != iVertexList.end(); va = vb)
+  {
+		vb++;
+    // Adds va to the vertex list:
+    //face->AddVertex(*va);
+
+    WOEdge * oedge;
+    if(*va == iVertexList.back())
+      oedge = face->MakeEdge(*va, iVertexList.front()); //for the last (closing) edge
+    else
+     oedge = face->MakeEdge(*va, *vb);
+
+
+    if(oedge == 0)
+      return 0;
+
+
+    WEdge *edge = oedge->GetOwner();
+    if(1 == edge->GetNumberOfOEdges())
+    {
+      // means that we just created a new edge and that we must add it to the 
+      // shape's edges list
+      edge->setId(_EdgeList.size());
+      AddEdge(edge);
+      // compute the mean edge value:
+      _meanEdgeSize += edge->GetaOEdge()->getVec3r().norm();
+    }
+  }
+  
+  // compute the face normal (v1v2 ^ v1v3)
+  WVertex *v1, *v2, *v3;
+  it = iVertexList.begin();
+  v1 = *it;
+  it++;
+  v2 = *it;
+  it++;
+  v3 = *it;
+
+  Vec3r vector1(v2->GetVertex()-v1->GetVertex());
+  Vec3r vector2(v3->GetVertex()-v1->GetVertex());
+
+  Vec3r normal(vector1 ^ vector2);
+  normal.normalize();
+  face->setNormal(normal);
+
+  // Add the face to the shape's faces list:
+  face->setId(id);
+  AddFace(face);
+
+  return face;
+}
diff --git a/source/blender/freestyle/intern/winged_edge/WEdge.h b/source/blender/freestyle/intern/winged_edge/WEdge.h
new file mode 100755
index 00000000000..99dc83faf96
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WEdge.h
@@ -0,0 +1,955 @@
+//
+//  Filename         : WEdge.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes to define a Winged Edge data structure.
+//  Date of creation : 18/02/2002
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  WEDGE_H
+# define WEDGE_H
+
+# include <vector>
+# include <iterator>
+# include "../system/FreestyleConfig.h"
+# include "../geometry/Geom.h"
+# include "../scene_graph/Material.h"
+
+using namespace std;
+using namespace Geometry;
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WVertex            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+class WOEdge;
+class WEdge;
+class WShape;
+class WFace;
+class LIB_WINGED_EDGE_EXPORT WVertex
+{
+protected:
+  int _Id;                    // an identificator
+  Vec3r _Vertex;
+  vector<WEdge*> _EdgeList;
+  WShape * _Shape; // the shape to which the vertex belongs
+  bool _Smooth; // flag to indicate whether the Vertex belongs to a smooth edge or not
+  int _Border; // 1 -> border, 0 -> no border, -1 -> not set
+  
+public:
+  void * userdata; // designed to store specific user data
+  inline WVertex(const Vec3r &v) {_Id = 0; _Vertex = v; userdata = NULL; _Shape = NULL;_Smooth=true;_Border=-1;}
+  /*! Copy constructor */
+  WVertex(WVertex& iBrother);
+  virtual WVertex * duplicate(); 
+  virtual ~WVertex() {}
+
+  /*! accessors */
+  inline Vec3r& GetVertex() {return _Vertex;}
+  inline vector<WEdge*>& GetEdges() {return _EdgeList;}
+  inline int GetId() {return _Id;}
+  inline WShape * shape() const {return _Shape;}
+  inline bool isSmooth() const {return _Smooth;}
+  bool isBoundary();
+  
+  /*! modifiers */
+  inline void setVertex(const Vec3r& v) {_Vertex = v;}
+  inline void setEdges(const vector<WEdge *>& iEdgeList) {_EdgeList = iEdgeList;}
+  inline void setId(int id) {_Id = id;}
+  inline void setShape(WShape *iShape) {_Shape = iShape;}
+  inline void setSmooth(bool b) {_Smooth = b;}
+  inline void setBorder(bool b) {if(b) _Border= 1; else _Border = 0;}
+  
+  /*! Adds an edge to the edges list */
+  void AddEdge(WEdge *iEdge) ;
+
+  virtual void ResetUserData() {userdata = 0;}
+
+
+
+public:
+
+  
+
+  /*! Iterator to iterate over a vertex incoming edges in the CCW order*/
+# if defined(__GNUC__) && (__GNUC__ < 3)
+  class incoming_edge_iterator : public input_iterator<WOEdge*,ptrdiff_t>
+# else
+  class LIB_WINGED_EDGE_EXPORT incoming_edge_iterator : public iterator<input_iterator_tag, WOEdge*,ptrdiff_t>
+# endif
+  {
+  private:
+    WVertex *_vertex;
+    // 
+    WOEdge *_begin;
+    WOEdge *_current;
+
+    public:
+# if defined(__GNUC__) && (__GNUC__ < 3)
+    inline incoming_edge_iterator() : input_iterator<WOEdge*,ptrdiff_t>() {}
+# else
+    inline incoming_edge_iterator() : iterator<input_iterator_tag, WOEdge*,ptrdiff_t>() {}
+# endif
+	virtual ~incoming_edge_iterator() {}; //soc
+
+  protected:
+    friend class WVertex;
+    inline incoming_edge_iterator(
+                         WVertex *iVertex,
+                         WOEdge * iBegin,
+                         WOEdge * iCurrent)
+# if defined(__GNUC__) && (__GNUC__ < 3)
+      : input_iterator<WOEdge*,ptrdiff_t>()
+# else
+      : iterator<input_iterator_tag, WOEdge*,ptrdiff_t>()
+# endif
+    {
+      _vertex = iVertex;
+      _begin = iBegin;
+      _current = iCurrent;
+    }
+
+  public:
+    inline incoming_edge_iterator(const incoming_edge_iterator& iBrother)
+# if defined(__GNUC__) && (__GNUC__ < 3)
+      : input_iterator<WOEdge*,ptrdiff_t>(iBrother)
+# else
+      : iterator<input_iterator_tag, WOEdge*,ptrdiff_t>(iBrother)
+# endif
+    {
+      _vertex = iBrother._vertex;
+      _begin = iBrother._begin;
+      _current = iBrother._current;
+    }
+
+  public:
+    // operators
+    virtual incoming_edge_iterator& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    virtual incoming_edge_iterator operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      incoming_edge_iterator tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    } 
+  
+    // comparibility
+    virtual bool operator!=(const incoming_edge_iterator& b) const
+    {
+      return ((_current) != (b._current));
+    }
+
+    virtual bool operator==(const incoming_edge_iterator& b) const
+    {
+      return ((_current)== (b._current));
+    }
+
+    // dereferencing
+    virtual WOEdge* operator*();
+    //virtual WOEdge** operator->();
+  protected:
+    virtual void increment();
+  };
+
+
+    /*! Iterator to iterate over a vertex faces in the CCW order */
+# if defined(__GNUC__) && (__GNUC__ < 3)
+  class face_iterator : public input_iterator<WFace*,ptrdiff_t>
+# else
+  class LIB_WINGED_EDGE_EXPORT face_iterator : public iterator<input_iterator_tag, WFace*,ptrdiff_t>
+# endif
+  {
+  private:
+    incoming_edge_iterator _edge_it;
+
+    public:
+# if defined(__GNUC__) && (__GNUC__ < 3)
+    inline face_iterator() : input_iterator<WFace*,ptrdiff_t>() {}
+# else
+    inline face_iterator() : iterator<input_iterator_tag, WFace*,ptrdiff_t>() {}
+# endif
+	virtual ~face_iterator() {}; //soc
+
+  protected:
+    friend class WVertex;
+    inline face_iterator(
+                         incoming_edge_iterator it)
+# if defined(__GNUC__) && (__GNUC__ < 3)
+      : input_iterator<WFace*,ptrdiff_t>()
+# else
+      : iterator<input_iterator_tag, WFace*,ptrdiff_t>()
+# endif
+    {
+      _edge_it = it;
+    }
+
+  public:
+    inline face_iterator(const face_iterator& iBrother)
+# if defined(__GNUC__) && (__GNUC__ < 3)
+      : input_iterator<WFace*,ptrdiff_t>(iBrother)
+# else
+      : iterator<input_iterator_tag, WFace*,ptrdiff_t>(iBrother)
+# endif
+    {
+      _edge_it = iBrother._edge_it;
+    }
+
+  public:
+    // operators
+    virtual face_iterator& operator++()  // operator corresponding to ++i
+    { 
+      increment();
+      return *this;
+    }
+    virtual face_iterator operator++(int)  // opérateur correspondant à i++ 
+    {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
+      face_iterator tmp = *this;        // C'est pour cela qu'on stocke la valeur
+      increment();                    // dans un temporaire. 
+      return tmp;
+    } 
+  
+    // comparibility
+    virtual bool operator!=(const face_iterator& b) const
+    {
+      return ((_edge_it) != (b._edge_it));
+    }
+
+    virtual bool operator==(const face_iterator& b) const
+    {
+      return ((_edge_it)== (b._edge_it));
+    }
+
+    // dereferencing
+    virtual WFace* operator*();
+    //virtual WOEdge** operator->();
+  protected:
+    inline void increment(){
+      ++_edge_it;
+    }
+  };
+
+public:
+  /*! iterators access */
+  virtual incoming_edge_iterator incoming_edges_begin();
+  virtual incoming_edge_iterator incoming_edges_end() ; 
+ 
+  virtual face_iterator faces_begin() {
+    return face_iterator(incoming_edges_begin());
+  }
+  virtual face_iterator faces_end()   {
+    return face_iterator(incoming_edges_end());
+  }
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WOEdge             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+class WFace;
+class WEdge;
+
+class LIB_WINGED_EDGE_EXPORT WOEdge
+{
+protected:
+  //  WOEdge *_paCWEdge;     // edge reached when traveling clockwise on aFace from the edge
+  //  WOEdge *_pbCWEdge;     // edge reached when traveling clockwise on bFace from the edge
+  //  WOEdge *_paCCWEdge;    // edge reached when traveling counterclockwise on aFace from the edge
+  //  WOEdge *_pbCCWEdge;    // edge reached when traveling counterclockwise on bFace from the edge
+  WVertex *_paVertex;   // starting vertex
+  WVertex *_pbVertex;   // ending vertex
+  WFace   *_paFace;     // when following the edge, face on the right
+  WFace   *_pbFace;     // when following the edge, face on the left
+  WEdge *_pOwner;       // Edge 
+
+public:
+  void *userdata;
+  inline WOEdge()
+  {
+    //    _paCWEdge = NULL;
+    //    _pbCWEdge = NULL;
+    //    _paCCWEdge = NULL;
+    //    _pbCCWEdge = NULL;
+    _paVertex = NULL;
+    _pbVertex = NULL;
+    _paFace = NULL;
+    _pbFace = NULL;
+    _pOwner = NULL;
+    userdata = NULL;
+  }
+  virtual ~WOEdge() {}; //soc
+
+  /*! copy constructor */
+  WOEdge(WOEdge& iBrother);
+  virtual WOEdge * duplicate();
+
+  /*! accessors */
+  //  inline WOEdge *GetaCWEdge() {return _paCWEdge;}
+  //  inline WOEdge *GetbCWEdge() {return _pbCWEdge;}
+  //  inline WOEdge *GetaCCWEdge() {return _paCCWEdge;}
+  //  inline WOEdge *GetbCCWEdge() {return _pbCCWEdge;}
+  inline WVertex *GetaVertex() {return _paVertex;}
+  inline WVertex *GetbVertex() {return _pbVertex;}
+  inline WFace *GetaFace() {return _paFace;}
+  inline WFace *GetbFace() {return _pbFace;}
+  inline WEdge *GetOwner() {return _pOwner;}
+  
+
+  /*! modifiers */
+  //  inline void SetaCWEdge(WOEdge *pe) {_paCWEdge = pe;}
+  //  inline void SetbCWEdge(WOEdge *pe) {_pbCWEdge = pe;}
+  //  inline void SetaCCWEdge(WOEdge *pe) {_paCCWEdge = pe;}
+  //  inline void SetbCCCWEdge(WOEdge *pe) {_pbCCWEdge = pe;}
+  inline void setaVertex(WVertex *pv) {_paVertex = pv;}
+  inline void setbVertex(WVertex *pv) {_pbVertex = pv;}
+  inline void setaFace(WFace *pf) {_paFace = pf;}
+  inline void setbFace(WFace *pf) {_pbFace = pf;}
+  inline void setOwner(WEdge *pe) {_pOwner = pe;}
+
+  /*! Retrieves the list of edges in CW order */
+  inline void RetrieveCWOrderedEdges(vector<WEdge*>& oEdges);
+  /*! returns the vector between the two vertices */
+  Vec3r getVec3r (); 
+  WOEdge * twin (); 
+  WOEdge * getPrevOnFace();
+  virtual void ResetUserData() {userdata = 0;}
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WEdge              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+class LIB_WINGED_EDGE_EXPORT WEdge
+{
+protected:
+  WOEdge *_paOEdge; // first oriented edge
+  WOEdge *_pbOEdge; // second oriented edge
+  int _nOEdges;     // number of oriented edges associated with this edge. (1 means border edge)
+  int    _Id;       // Identifier for the edge
+  
+public:
+  void * userdata; // designed to store specific user data
+  inline WEdge()
+  {
+    _paOEdge = NULL;
+    _pbOEdge = NULL;
+    _nOEdges = 0;
+    userdata = NULL;
+  }
+
+  inline WEdge(WOEdge *iOEdge)
+  {
+    _paOEdge = iOEdge;
+    _pbOEdge = NULL;
+    _nOEdges = 1;
+    userdata = NULL;
+  }
+
+  inline WEdge(WOEdge *iaOEdge, WOEdge *ibOEdge)
+  {
+    _paOEdge = iaOEdge;
+    _pbOEdge = ibOEdge;
+    _nOEdges = 2;
+    userdata = NULL;
+  }
+
+  /*! Copy constructor */
+  WEdge(WEdge& iBrother);
+  virtual WEdge * duplicate();
+
+  virtual ~WEdge()
+  {
+    if(NULL != _paOEdge)
+    {
+      delete _paOEdge;
+      _paOEdge = NULL;
+    }
+
+    if(NULL != _pbOEdge)
+    {
+      delete _pbOEdge;
+      _pbOEdge = NULL;
+    }
+  }
+
+  /*! checks whether two WEdge have a common vertex.
+   *  Returns a pointer on the common vertex if it exists, 
+   *  NULL otherwise.
+   */
+  static inline WVertex* CommonVertex(WEdge *iEdge1, WEdge* iEdge2)
+  {
+    if((NULL == iEdge1) || (NULL == iEdge2))
+      return NULL;
+
+    WVertex *wv1 = iEdge1->GetaOEdge()->GetaVertex();
+    WVertex *wv2 = iEdge1->GetaOEdge()->GetbVertex();
+    WVertex *wv3 = iEdge2->GetaOEdge()->GetaVertex();
+    WVertex *wv4 = iEdge2->GetaOEdge()->GetbVertex();
+
+    if((wv1 == wv3) || (wv1 == wv4))
+    {
+      return wv1;
+    }
+    else if((wv2 == wv3) || (wv2 == wv4))
+    {
+      return wv2;
+    }
+
+    return NULL;
+  }
+  /*! accessors */
+  inline WOEdge * GetaOEdge() {return _paOEdge;}
+  inline WOEdge * GetbOEdge() {return _pbOEdge;}
+  inline int GetNumberOfOEdges() {return _nOEdges;}
+  inline int    GetId()    {return _Id;}
+  inline WVertex * GetaVertex() {return _paOEdge->GetaVertex();}
+  inline WVertex * GetbVertex() {return _paOEdge->GetbVertex();}
+  inline WFace * GetaFace() {return _paOEdge->GetaFace();}
+  inline WFace * GetbFace() {return _paOEdge->GetbFace();}
+  inline WOEdge* GetOtherOEdge(WOEdge* iOEdge)
+  {
+    if(iOEdge == _paOEdge)
+      return _pbOEdge;
+    else
+      return _paOEdge;
+  }
+
+  /*! modifiers */
+  inline void setaOEdge(WOEdge *iEdge) {_paOEdge = iEdge;}
+  inline void setbOEdge(WOEdge *iEdge) {_pbOEdge = iEdge;}
+  inline void AddOEdge(WOEdge *iEdge) 
+  {
+    if(NULL == _paOEdge)
+    {
+      _paOEdge = iEdge;
+      _nOEdges++;
+      return;
+    }
+    if(NULL == _pbOEdge)
+    {
+      _pbOEdge = iEdge;
+      _nOEdges++;
+      return;
+    }
+  }
+  inline void setNumberOfOEdges(int n) {_nOEdges = n;}
+  inline void setId(int id) {_Id = id;}
+  virtual void ResetUserData() {userdata = 0;}
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WFace              */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+class LIB_WINGED_EDGE_EXPORT WFace
+{
+protected:
+  vector<WOEdge *> _OEdgeList; // list of oriented edges of bording the face
+  Vec3r _Normal;              // normal to the face
+  vector<Vec3r> _VerticesNormals; // in case there is a normal per vertex.
+                                  // The normal number i corresponds to the 
+                                  // aVertex of the oedge number i, for that face
+  vector<Vec2r> _VerticesTexCoords;
+
+  int   _Id;
+  unsigned _MaterialIndex;
+
+public:
+  void *userdata;
+  inline WFace() {userdata = NULL;_MaterialIndex = 0;}
+  /*! copy constructor */
+  WFace(WFace& iBrother);
+  virtual WFace * duplicate();
+  virtual ~WFace() {}
+
+  /*! accessors */
+  inline const vector<WOEdge*>& GetEdgeList() {return _OEdgeList;}
+  inline WOEdge * GetOEdge(int i) {return _OEdgeList[i];}
+  inline Vec3r& GetNormal() {return _Normal;}
+  inline int    GetId()     {return _Id;}
+  inline unsigned materialIndex() const {return _MaterialIndex;}
+  const Material& material()  ;
+
+  /*! The vertex of index i corresponds to the a vertex 
+   *  of the edge of index i
+   */
+  inline WVertex* GetVertex(unsigned int index)
+  {
+    //    if(index >= _OEdgeList.size())
+    //      return NULL;
+    return _OEdgeList[index]->GetaVertex();
+  }
+  /*! returns the index at which iVertex is stored in the 
+   * array.
+   * returns -1 if iVertex doesn't belong to the face.
+   */
+  inline int GetIndex(WVertex *iVertex){
+    int index = 0;
+    for(vector<WOEdge*>::iterator woe=_OEdgeList.begin(), woend=_OEdgeList.end();
+    woe!=woend;
+    woe++){
+      if((*woe)->GetaVertex() == iVertex)
+        return index;
+      ++index;
+    } 
+    return -1;
+  }
+  inline void RetrieveVertexList(vector<WVertex*>& oVertices)
+  {
+    for(vector<WOEdge*>::iterator woe=_OEdgeList.begin(), woend=_OEdgeList.end();
+        woe!=woend;
+        woe++)
+      {
+        oVertices.push_back((*woe)->GetaVertex());
+      }
+  }
+  inline void  RetrieveBorderFaces(vector<const WFace*>& oWFaces)
+  {
+    for(vector<WOEdge*>::iterator woe=_OEdgeList.begin(), woend=_OEdgeList.end();
+    woe!=woend;
+    woe++)
+    {
+      WFace *af;
+      if(NULL != (af = (*woe)->GetaFace()))
+      oWFaces.push_back(af);
+    }
+  }
+  inline WFace * GetBordingFace(int index)
+  {
+    //    if(index >= _OEdgeList.size())
+    //      return 0;
+    return _OEdgeList[index]->GetaFace();
+  }
+  inline WFace * GetBordingFace(WOEdge *iOEdge)
+  {
+    return iOEdge->GetaFace();
+  }
+  inline vector<Vec3r>& GetPerVertexNormals()
+  {
+    return _VerticesNormals;
+  }
+  inline vector<Vec2r>& GetPerVertexTexCoords()
+  {
+      return _VerticesTexCoords;
+  }
+  /*! Returns the normal of the vertex of index index */
+  inline Vec3r& GetVertexNormal(int index)
+  {
+      return _VerticesNormals[index];
+  }
+  /*! Returns the tex coords of the vertex of index index */
+  inline Vec2r& GetVertexTexCoords(int index)
+  {
+    return _VerticesTexCoords[index];
+  }
+  /*! Returns the normal of the vertex iVertex for that face */
+  inline Vec3r& GetVertexNormal(WVertex *iVertex)
+  {
+    int i = 0;
+    int index = 0;
+    for(vector<WOEdge*>::const_iterator woe=_OEdgeList.begin(), woend=_OEdgeList.end();
+        woe!=woend;
+        woe++)
+      {
+        if((*woe)->GetaVertex() == iVertex)
+        {
+          index = i;
+          break;
+        }
+        ++i;
+      }
+
+    return _VerticesNormals[index];
+  }
+  inline WOEdge* GetNextOEdge(WOEdge* iOEdge)
+  {
+    bool found = false;
+    vector<WOEdge*>::iterator woe,woend, woefirst;
+    woefirst = _OEdgeList.begin();
+    for(woe=woefirst,woend=_OEdgeList.end();
+        woe!=woend;
+        woe++)
+      {
+        if(true == found)
+          return (*woe);
+        
+        if((*woe) == iOEdge)
+          {
+            found = true;
+          }
+      }
+    
+    // We left the loop. That means that the first
+    // OEdge was the good one:
+    if(found)
+      return (*woefirst);
+
+    return NULL;
+  }
+  WOEdge* GetPrevOEdge(WOEdge* iOEdge);
+ 
+  inline int numberOfEdges() const { return _OEdgeList.size();}
+  inline int numberOfVertices() const { return _OEdgeList.size();}
+  /*! Returns true if the face has one ot its edge which is a border 
+   *  edge
+   */
+  inline bool isBorder() const 
+  {
+    for(vector<WOEdge*>::const_iterator woe=_OEdgeList.begin(), woeend=_OEdgeList.end();
+    woe!=woeend;
+    ++woe)
+    {
+      if((*woe)->GetOwner()->GetbOEdge() == 0)
+        return true;
+    }
+    return false;
+  }
+  /*! modifiers */
+  inline void setEdgeList(const vector<WOEdge*>& iEdgeList) {_OEdgeList = iEdgeList;}
+  inline void setNormal(const Vec3r& iNormal) {_Normal = iNormal;}
+  inline void setNormalList(const vector<Vec3r>& iNormalsList) {_VerticesNormals = iNormalsList;}
+  inline void setTexCoordsList(const vector<Vec2r>& iTexCoordsList) {_VerticesTexCoords = iTexCoordsList;}
+  inline void setId(int id) {_Id = id;}
+  inline void setMaterialIndex(unsigned iMaterialIndex) {_MaterialIndex = iMaterialIndex;}
+
+  /*! designed to build a specialized WEdge 
+   *  for use in MakeEdge
+   */
+  virtual WEdge * instanciateEdge() const {return new WEdge;}
+
+  /*! Builds an oriented edge
+   *  Returns the built edge.
+   *    v1, v2
+   *      Vertices at the edge's extremities
+   *      The edge is oriented from v1 to v2.
+   */
+  virtual WOEdge * MakeEdge(WVertex *v1, WVertex *v2);
+
+  /*! Adds an edge to the edges list */
+  inline void AddEdge(WOEdge *iEdge) {_OEdgeList.push_back(iEdge);}
+
+  /*! For triangles, returns the edge opposite to the vertex in e. 
+      returns flase if the face is not a triangle or if the vertex is not found*/
+  bool getOppositeEdge (const WVertex *v, WOEdge* &e); 
+
+  /*! compute the area of the face */
+  real getArea ();
+
+  WShape * getShape() ;
+  virtual void ResetUserData() {userdata = 0;}
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WShape             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+class LIB_WINGED_EDGE_EXPORT WShape
+{
+protected:
+  vector<WVertex*> _VertexList;
+  vector<WEdge*>   _EdgeList;
+  vector<WFace*>   _FaceList;
+  int _Id; 
+  static unsigned _SceneCurrentId;
+  Vec3r _min;
+  Vec3r _max;
+  vector<Material> _Materials;
+  real _meanEdgeSize;
+
+public:
+  inline WShape() {_meanEdgeSize = 0;_Id = _SceneCurrentId; _SceneCurrentId++;}
+  /*! copy constructor */
+  WShape(WShape& iBrother);
+  virtual WShape * duplicate();
+  virtual ~WShape()
+  {
+    if(_EdgeList.size() != 0)
+    {
+      vector<WEdge *>::iterator e;
+      for(e=_EdgeList.begin(); e!=_EdgeList.end(); e++)
+      {
+        delete (*e);
+      }
+      _EdgeList.clear();
+    }
+
+    if(_VertexList.size() != 0)
+    {
+      vector<WVertex *>::iterator v;
+      for(v=_VertexList.begin(); v!=_VertexList.end(); v++)
+      {
+        delete (*v);
+      }
+      _VertexList.clear();
+    }
+
+    if(_FaceList.size() != 0)
+    {
+      vector<WFace *>::iterator f;
+      for(f=_FaceList.begin(); f!=_FaceList.end(); f++)
+      {
+        delete (*f);
+      }
+      _FaceList.clear();
+    }
+  }
+
+  /*! accessors */
+  inline vector<WEdge *>& GetEdgeList() {return _EdgeList;}
+  inline vector<WVertex*>& GetVertexList() {return _VertexList;}
+  inline vector<WFace*>& GetFaceList() {return _FaceList;}
+  inline unsigned GetId() {return _Id;}
+  inline void bbox(Vec3r& min, Vec3r& max) {min=_min; max=_max;}
+  inline const Material& material(unsigned i) const  {return _Materials[i];}
+  inline const vector<Material>& materials() const {return _Materials;}
+  inline const real getMeanEdgeSize() const {return _meanEdgeSize;}
+  /*! modifiers */
+  static inline void setCurrentId(const unsigned id) { _SceneCurrentId = id; }
+  inline void setEdgeList(const vector<WEdge*>& iEdgeList) {_EdgeList = iEdgeList;}
+  inline void setVertexList(const vector<WVertex*>& iVertexList) {_VertexList = iVertexList;}
+  inline void setFaceList(const vector<WFace*>& iFaceList) {_FaceList = iFaceList;}
+  inline void setId(int id) {_Id = id;}
+  inline void setBBox(const Vec3r& min, const Vec3r& max) {_min = min; _max=max;}
+  inline void setMaterial(const Material& material, unsigned i) {_Materials[i]=material;}
+  inline void setMaterials(const vector<Material>& iMaterials) {_Materials = iMaterials;}
+
+  /*! designed to build a specialized WFace 
+   *  for use in MakeFace
+   */
+  virtual WFace * instanciateFace() const {return new WFace;}
+
+  /*! adds a new face to the shape 
+   *  returns the built face.
+   *   iVertexList 
+   *      List of face's vertices. These vertices are 
+   *      not added to the WShape vertex list; they are 
+   *      supposed to be already stored when calling MakeFace.
+   *      The order in which the vertices are stored in the list 
+   *      determines the face's edges orientation and (so) the 
+   *      face orientation.
+   *   iMaterialIndex
+   *      The material index for this face 
+   */
+  virtual WFace * MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterialIndex);
+
+  /*! adds a new face to the shape. The difference with 
+   *  the previous method is that this one is designed 
+   *  to build a WingedEdge structure for which there are 
+   *  per vertex normals, opposed to per face normals.
+   *  returns the built face.
+   *   iVertexList 
+   *      List of face's vertices. These vertices are 
+   *      not added to the WShape vertex list; they are 
+   *      supposed to be already stored when calling MakeFace.
+   *      The order in which the vertices are stored in the list 
+   *      determines the face's edges orientation and (so) the 
+   *      face orientation.
+   *   iMaterialIndex
+   *      The materialIndex for this face
+   *   iNormalsList
+   *     The list of normals, iNormalsList[i] corresponding to the 
+   *     normal of the vertex iVertexList[i] for that face.
+   *   iTexCoordsList
+   *     The list of tex coords, iTexCoordsList[i] corresponding to the 
+   *     normal of the vertex iVertexList[i] for that face.
+   */
+  virtual WFace * MakeFace(vector<WVertex*>& iVertexList, vector<Vec3r>& iNormalsList, vector<Vec2r>& iTexCoordsList, unsigned iMaterialIndex);
+
+  inline void AddEdge(WEdge *iEdge) {_EdgeList.push_back(iEdge);}
+  inline void AddFace(WFace* iFace) {_FaceList.push_back(iFace);}
+  inline void AddVertex(WVertex *iVertex) {iVertex->setShape(this); _VertexList.push_back(iVertex);}
+
+  inline void ResetUserData()
+  {
+    for(vector<WVertex*>::iterator v=_VertexList.begin(),vend=_VertexList.end();
+        v!=vend;
+        v++)
+      {
+        (*v)->ResetUserData();
+      }
+
+    for(vector<WEdge*>::iterator e=_EdgeList.begin(),eend=_EdgeList.end();
+        e!=eend;
+        e++)
+      {
+        (*e)->ResetUserData();
+        // manages WOEdge:
+        WOEdge *oe = (*e)->GetaOEdge();
+        if(oe != NULL)
+          oe->ResetUserData();
+        oe = (*e)->GetbOEdge();
+        if(oe != NULL)
+          oe->ResetUserData();
+      }
+
+    for(vector<WFace*>::iterator f=_FaceList.begin(),fend=_FaceList.end();
+        f!=fend;
+        f++)
+      {
+        (*f)->ResetUserData();
+      }
+    
+  }
+
+  inline void ComputeBBox()
+  {
+    _min = _VertexList[0]->GetVertex();
+    _max = _VertexList[0]->GetVertex();
+
+    Vec3r v;
+    for(vector<WVertex*>::iterator wv=_VertexList.begin(), wvend=_VertexList.end();
+    wv!=wvend;
+    wv++)
+    {
+      for(unsigned int i=0; i<3; i++)
+      {
+        v = (*wv)->GetVertex();
+        if(v[i] < _min[i])
+          _min[i] = v[i];
+        if(v[i] > _max[i])
+          _max[i] = v[i];
+      }
+    }
+  }
+
+  inline real ComputeMeanEdgeSize(){
+    _meanEdgeSize = _meanEdgeSize/(_EdgeList.size());
+    return _meanEdgeSize;
+  }
+
+protected:
+  /*! Builds the face passed as argument (which as already been allocated)
+   *    iVertexList
+   *      List of face's vertices. These vertices are 
+   *      not added to the WShape vertex list; they are 
+   *      supposed to be already stored when calling MakeFace.
+   *      The order in which the vertices are stored in the list 
+   *      determines the face's edges orientation and (so) the 
+   *      face orientation.
+   *    iMaterialIndex
+   *      The material index for this face
+   *    face
+   *      The Face that is filled in
+   */
+  virtual WFace * MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterialIndex, WFace *face);
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*          WingedEdge            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+class WingedEdge {
+
+ public:
+
+  WingedEdge() {}
+
+  ~WingedEdge() {
+    clear();
+  }
+
+  void clear() {
+    for (vector<WShape*>::iterator it = _wshapes.begin();
+	 it != _wshapes.end();
+	 it++)
+      delete *it;
+    _wshapes.clear();
+  }
+
+  void addWShape(WShape* wshape) {
+    _wshapes.push_back(wshape);
+  }
+
+  vector<WShape*>& getWShapes() {
+    return _wshapes;
+  }
+
+ private:
+
+  vector<WShape*>	_wshapes;
+};
+
+
+
+/*
+  
+  #############################################
+  #############################################
+  #############################################
+  ######                                 ######
+  ######   I M P L E M E N T A T I O N   ######
+  ######                                 ######
+  #############################################
+  #############################################
+  #############################################
+  
+*/
+/* for inline functions */
+void WOEdge::RetrieveCWOrderedEdges(vector<WEdge*>& oEdges)
+{
+    
+    WOEdge *currentOEdge = this;
+    do
+      {
+        WOEdge* nextOEdge = currentOEdge->GetbFace()->GetNextOEdge(currentOEdge);
+        oEdges.push_back(nextOEdge->GetOwner());
+        currentOEdge = nextOEdge->GetOwner()->GetOtherOEdge(nextOEdge);
+        
+      } while((currentOEdge != NULL) && (currentOEdge->GetOwner() != GetOwner()));
+}
+
+#endif // WEDGE_H
diff --git a/source/blender/freestyle/intern/winged_edge/WFillGrid.cpp b/source/blender/freestyle/intern/winged_edge/WFillGrid.cpp
new file mode 100755
index 00000000000..7d0a2d3c561
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WFillGrid.cpp
@@ -0,0 +1,60 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "WEdge.h"
+#include "WFillGrid.h"
+
+void WFillGrid::fillGrid() {
+  if (!_winged_edge || !_grid)
+    return;
+
+  vector<WShape*>	wshapes = _winged_edge->getWShapes();
+  vector<WVertex*>	fvertices;
+  vector<Vec3r>		vectors;
+  vector<WFace*>	faces;
+
+  for (vector<WShape*>::const_iterator it = wshapes.begin();
+       it != wshapes.end();
+       it++) {
+    faces = (*it)->GetFaceList();
+
+    for (vector<WFace*>::const_iterator f = faces.begin();
+	 f != faces.end();
+	 f++) {
+      (*f)->RetrieveVertexList(fvertices);
+
+      for (vector<WVertex*>::const_iterator wv = fvertices.begin();
+	   wv != fvertices.end();
+	   wv++)
+        vectors.push_back(Vec3r((*wv)->GetVertex()));
+
+      // occluder will be deleted by the grid
+      Polygon3r *occluder =
+	new Polygon3r(vectors, (*f)->GetNormal());
+      occluder->setId(_polygon_id++);
+      occluder->userdata = (void*)(*f);
+      _grid->insertOccluder(occluder);
+      vectors.clear();
+      fvertices.clear();
+    }
+    faces.clear();
+  }
+}
diff --git a/source/blender/freestyle/intern/winged_edge/WFillGrid.h b/source/blender/freestyle/intern/winged_edge/WFillGrid.h
new file mode 100755
index 00000000000..2ebbc2f359a
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WFillGrid.h
@@ -0,0 +1,80 @@
+//
+//  Filename         : WFillGrid.h
+//  Author(s)        : Stephane Grabli
+//                     Emmanuel Turquin 
+//  Purpose          : Class to fill in a grid from a SceneGraph
+//                     (uses only the WingedEdge structures)
+//  Date of creation : 03/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  W_FILL_GRID_H
+# define W_FILL_GRID_H
+
+# include "../geometry/Grid.h" 
+# include "../geometry/Polygon.h"
+# include "WEdge.h"
+
+class LIB_WINGED_EDGE_EXPORT WFillGrid
+{
+public:
+
+  inline WFillGrid(Grid* grid = 0, WingedEdge* winged_edge = 0) {
+    _winged_edge = winged_edge;
+    _grid = grid;
+    _polygon_id = 0;
+  }
+
+  virtual ~WFillGrid() {}
+
+  void fillGrid();
+
+  /*! Accessors */
+  WingedEdge* getWingedEdge() {
+    return _winged_edge;
+  }
+
+  Grid* getGrid() {
+    return _grid;
+  }
+
+  /*! Modifiers */
+  void setWingedEdge(WingedEdge* winged_edge) {
+    if (winged_edge)
+      _winged_edge = winged_edge;
+  }
+
+  void setGrid(Grid* grid) {
+    if (grid)
+      _grid = grid;
+  }
+
+private:
+
+  Grid*		_grid;
+  WingedEdge*	_winged_edge;
+  unsigned	_polygon_id;
+};
+
+#endif // WS_FILL_GRID_H
diff --git a/source/blender/freestyle/intern/winged_edge/WSFillGrid.cpp b/source/blender/freestyle/intern/winged_edge/WSFillGrid.cpp
new file mode 100755
index 00000000000..55fa418d4f5
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WSFillGrid.cpp
@@ -0,0 +1,60 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "WEdge.h"
+#include "WSFillGrid.h"
+
+void WSFillGrid::fillGrid() {
+  if (!_winged_edge || !_grid)
+    return;
+
+  vector<WShape*>	wshapes = _winged_edge->getWShapes();
+  vector<WVertex*>	fvertices;
+  vector<Vec3r>		vectors;
+  vector<WFace*>	faces;
+
+  for (vector<WShape*>::const_iterator it = wshapes.begin();
+       it != wshapes.end();
+       it++) {
+    faces = (*it)->GetFaceList();
+
+    for (vector<WFace*>::const_iterator f = faces.begin();
+	 f != faces.end();
+	 f++) {
+      (*f)->RetrieveVertexList(fvertices);
+
+      for (vector<WVertex*>::const_iterator wv = fvertices.begin();
+	   wv != fvertices.end();
+	   wv++)
+        vectors.push_back(Vec3r((*wv)->GetVertex()));
+
+      // occluder will be deleted by the grid
+      Polygon3r *occluder =
+	new Polygon3r(vectors, (*f)->GetNormal());
+      occluder->setId(_polygon_id++);
+      occluder->userdata = (void*)(*f);
+      _grid->insertOccluder(occluder);
+      vectors.clear();
+      fvertices.clear();
+    }
+    faces.clear();
+  }
+}
diff --git a/source/blender/freestyle/intern/winged_edge/WSFillGrid.h b/source/blender/freestyle/intern/winged_edge/WSFillGrid.h
new file mode 100755
index 00000000000..2ea5bc6c621
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WSFillGrid.h
@@ -0,0 +1,79 @@
+//
+//  Filename         : WSFillGrid.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to fill in a grid from a SceneGraph
+//                     (uses only the WingedEdge structures)
+//  Date of creation : 03/05/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  WS_FILL_GRID_H
+# define WS_FILL_GRID_H
+
+# include "../geometry/Grid.h" 
+# include "../geometry/Polygon.h"
+# include "WEdge.h"
+
+class LIB_WINGED_EDGE_EXPORT WSFillGrid
+{
+public:
+
+  inline WSFillGrid(Grid* grid = 0, WingedEdge* winged_edge = 0) {
+    _winged_edge = winged_edge;
+    _grid = grid;
+    _polygon_id = 0;
+  }
+
+  virtual ~WSFillGrid() {}
+
+  void fillGrid();
+
+  /*! Accessors */
+  WingedEdge* getWingedEdge() {
+    return _winged_edge;
+  }
+
+  Grid* getGrid() {
+    return _grid;
+  }
+
+  /*! Modifiers */
+  void setWingedEdge(WingedEdge* winged_edge) {
+    if (winged_edge)
+      _winged_edge = winged_edge;
+  }
+
+  void setGrid(Grid* grid) {
+    if (grid)
+      _grid = grid;
+  }
+
+private:
+
+  Grid*		_grid;
+  WingedEdge*	_winged_edge;
+  unsigned	_polygon_id;
+};
+
+#endif // WS_FILL_GRID_H
diff --git a/source/blender/freestyle/intern/winged_edge/WXEdge.cpp b/source/blender/freestyle/intern/winged_edge/WXEdge.cpp
new file mode 100755
index 00000000000..ff567aee06a
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WXEdge.cpp
@@ -0,0 +1,296 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "WXEdge.h"
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXFace             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+unsigned int WXFaceLayer::Get0VertexIndex() const {
+  int i = 0;
+  int nEdges = _pWXFace->numberOfEdges();
+  for(i=0; i<nEdges; ++i){
+    if(_DotP[i] == 0){
+      return i;
+    }
+  }
+  return -1;
+}
+unsigned int WXFaceLayer::GetSmoothEdgeIndex() const{
+  int i = 0;
+  int nEdges = _pWXFace->numberOfEdges();
+  for(i=0; i<nEdges; ++i){
+    if((_DotP[i] == 0) && (_DotP[(i+1)%nEdges] == 0)){
+      return i;
+    }
+  }
+ return -1;
+}
+
+void WXFaceLayer::RetrieveCuspEdgesIndices(vector<int>& oCuspEdges){
+  int i = 0;
+  int nEdges = _pWXFace->numberOfEdges();
+  for(i=0; i<nEdges; ++i){
+    if(_DotP[i]*_DotP[(i+1)%nEdges] < 0){
+      // we got one
+      oCuspEdges.push_back(i);
+    }
+  }
+}
+  
+WXSmoothEdge* WXFaceLayer::BuildSmoothEdge(){ 
+  // if the smooth edge has already been 
+  // built: exit
+  if(0 != _pSmoothEdge)
+    return _pSmoothEdge;
+  real ta, tb;
+  WOEdge *woea(0), *woeb(0);
+  bool ok = false;
+  vector<int> cuspEdgesIndices;
+  int indexStart, indexEnd;
+  unsigned nedges = _pWXFace->numberOfEdges();
+  if(_nNullDotP == nedges){
+    _pSmoothEdge = 0;
+    return _pSmoothEdge;
+  }
+  if((_nPosDotP != 0) && (_nPosDotP != _DotP.size()) && (_nNullDotP == 0)){
+    // that means that we have a smooth edge that starts from 
+    // an edge and ends at an edge
+    //-----------------------------
+    // We retrieve the 2 edges for which we have
+    // opposite signs for each extremity
+    RetrieveCuspEdgesIndices(cuspEdgesIndices);
+    if(cuspEdgesIndices.size() != 2) // we necessarly have 2 cusp edges
+      return 0;
+    
+    // let us determine which cusp edge corresponds to the starting:
+    // We can do that because we defined that 
+    // a silhouette edge had the back facing part on its right.
+    // So if the WOEdge woea is such that woea[0].dotp > 0 and 
+    // woea[1].dotp < 0, it is the starting edge.
+    //-------------------------------------------
+    
+    if(_DotP[cuspEdgesIndices[0]] > 0){
+      woea = _pWXFace->GetOEdge(cuspEdgesIndices[0]);
+      woeb = _pWXFace->GetOEdge(cuspEdgesIndices[1]);
+      indexStart = cuspEdgesIndices[0];
+      indexEnd = cuspEdgesIndices[1];
+    }else{
+      woea = _pWXFace->GetOEdge(cuspEdgesIndices[1]);
+      woeb = _pWXFace->GetOEdge(cuspEdgesIndices[0]);
+      indexStart = cuspEdgesIndices[1];
+      indexEnd = cuspEdgesIndices[0];
+    }
+    
+    // Compute the interpolation:
+    ta = _DotP[indexStart]/(_DotP[indexStart]-_DotP[(indexStart+1)%nedges]);
+    tb = _DotP[indexEnd]/(_DotP[indexEnd]-_DotP[(indexEnd+1)%nedges]);
+    ok = true;
+  }else if(_nNullDotP == 1){
+    // that means that we have exactly one of the 
+    // 2 extremities of our silhouette edge is 
+    // a vertex of the mesh
+    if((_nPosDotP == 2) || (_nPosDotP == 0)){
+      _pSmoothEdge = 0;
+      return _pSmoothEdge;
+    }
+    RetrieveCuspEdgesIndices(cuspEdgesIndices);
+    // We should have only one EdgeCusp:
+    if(cuspEdgesIndices.size() != 1){
+      cout << "Warning in BuildSmoothEdge: weird WXFace configuration" << endl;
+      _pSmoothEdge = 0;
+      return 0;
+    }
+    unsigned index0 = Get0VertexIndex(); // retrieve the 0 vertex index
+    unsigned nedges = _pWXFace->numberOfEdges();
+    if(_DotP[cuspEdgesIndices[0]] > 0){
+      woea = _pWXFace->GetOEdge(cuspEdgesIndices[0]);
+      woeb = _pWXFace->GetOEdge(index0);
+      indexStart = cuspEdgesIndices[0];
+      ta = _DotP[indexStart]/(_DotP[indexStart]-_DotP[(indexStart+1)%nedges]);
+      tb = 0.0;
+    }else{
+      woea = _pWXFace->GetOEdge(index0);
+      woeb = _pWXFace->GetOEdge(cuspEdgesIndices[0]);
+      indexEnd = cuspEdgesIndices[0];
+      ta = 0.0;
+      tb = _DotP[indexEnd]/(_DotP[indexEnd]-_DotP[(indexEnd+1)%nedges]);
+    }
+    ok = true;
+  }else if(_nNullDotP == 2){
+    // that means that the silhouette edge 
+    // is an edge of the mesh
+    int index = GetSmoothEdgeIndex();
+    if(!_pWXFace->front()) {// is it in the right order ?
+      // the order of the WOEdge index is wrong
+      woea = _pWXFace->GetOEdge((index+1)%nedges);
+      woeb = _pWXFace->GetOEdge((index-1)%nedges);
+      ta = 0;
+      tb = 1;
+      ok = true;
+    }else{
+      // here it's not good, our edge is a single point -> skip that face
+      ok = false;
+      // the order of the WOEdge index is good
+      //      woea = _pWXFace->GetOEdge((index-1)%nedges);
+      //      woeb = _pWXFace->GetOEdge((index+1)%nedges);
+      //      ta = 1;
+      //      tb = 0;
+    }
+  }
+  if(ok){
+    _pSmoothEdge = new WXSmoothEdge;
+    _pSmoothEdge->setWOeA(woea);
+    _pSmoothEdge->setWOeB(woeb);
+    _pSmoothEdge->setTa(ta);
+    _pSmoothEdge->setTb(tb);
+    if(_Nature & Nature::SILHOUETTE){
+      if(_nNullDotP != 2){
+        if(_DotP[_ClosestPointIndex] + 0.01 > 0)
+          _pSmoothEdge->setFront(true);
+        else
+          _pSmoothEdge->setFront(false); 
+      }
+    }
+  }
+    
+  // check bording edges to see if they have different dotp values 
+  // in bording faces.
+  //    for(int i=0; i<numberOfEdges(); i++)
+  //    {
+  //      WSFace * bface = (WSFace*)GetBordingFace(i);
+  //      if(bface != 0)
+  //      {
+  //        if((front())^(bface->front())) // fA->front XOR fB->front (true if one is 0 and the other is 1)
+  //        {
+  //          // that means that the edge i of the face is 
+  //          // a silhouette edge
+  //          // TESTER D'ABORD SI LE EXACTSILHOUETTEEDGE N'A PAS 
+  //          // ETE CONSTRUIT SUR L'AUTRE FACE.(1 suffit)
+  //          if(0 != ((WSExactFace*)bface)->exactSilhouetteEdge())
+  //          {
+  //            // that means that this silhouette edge has already been built
+  //            return ((WSExactFace*)bface)->exactSilhouetteEdge();
+  //          }
+  //          // Else we must build it
+  //          WOEdge *woea, *woeb;
+  //          real ta, tb;
+  //          if(!front()) // is it in the right order ?
+  //          { 
+  //            // the order of the WOEdge index is wrong
+  //            woea = _OEdgeList[(i+1)%numberOfEdges()];
+  //            if(0 == i)
+  //              woeb = _OEdgeList[numberOfEdges()-1];
+  //            else
+  //              woeb = _OEdgeList[(i-1)];
+  //            ta = 0;
+  //            tb = 1;
+  //          }
+  //          else
+  //          {
+  //            // the order of the WOEdge index is good
+  //            if(0 == i)
+  //              woea = _OEdgeList[numberOfEdges()-1];
+  //            else
+  //              woea = _OEdgeList[(i-1)];
+  //            woeb = _OEdgeList[(i+1)%numberOfEdges()];
+  //            ta = 1;
+  //            tb = 0;
+  //          } 
+  //      
+  //        _pSmoothEdge = new ExactSilhouetteEdge(ExactSilhouetteEdge::VERTEX_VERTEX);
+  //        _pSmoothEdge->setWOeA(woea);
+  //        _pSmoothEdge->setWOeA(woeb);
+  //        _pSmoothEdge->setTa(ta);
+  //        _pSmoothEdge->setTb(tb);
+  //
+  //        return _pSmoothEdge;
+  //        }
+  //  }
+  //}
+  return _pSmoothEdge;
+}
+ 
+
+void WXFace::ComputeCenter()
+{
+  vector<WVertex*> iVertexList;
+  RetrieveVertexList(iVertexList);
+  Vec3r center;
+  for(vector<WVertex*>::iterator wv=iVertexList.begin(),wvend=iVertexList.end();
+  wv!=wvend;
+  wv++)
+  {
+    center += (*wv)->GetVertex();
+  }
+  center /= (real)iVertexList.size();
+  setCenter(center);
+}
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXShape            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+WFace* WXShape::MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterialIndex)
+{
+  WFace *face = WShape::MakeFace(iVertexList, iMaterialIndex);
+  if(0 == face)
+    return 0;
+  
+  Vec3r center;
+  for(vector<WVertex*>::iterator wv=iVertexList.begin(),wvend=iVertexList.end();
+  wv!=wvend;
+  wv++)
+  {
+    center += (*wv)->GetVertex();
+  }
+  center /= (real)iVertexList.size();
+  ((WXFace*)face)->setCenter(center);
+
+  return face;
+}
+
+WFace * WXShape::MakeFace(vector<WVertex*>& iVertexList, vector<Vec3r>& iNormalsList, vector<Vec2r>& iTexCoordsList, unsigned iMaterialIndex)
+{
+  WFace *face = WShape::MakeFace(iVertexList, iNormalsList, iTexCoordsList, iMaterialIndex);
+  
+  //  Vec3r center;
+  //  for(vector<WVertex*>::iterator wv=iVertexList.begin(),wvend=iVertexList.end();
+  //  wv!=wvend;
+  //  wv++)
+  //  {
+  //    center += (*wv)->GetVertex();
+  //  }
+  //  center /= (real)iVertexList.size();
+  //  ((WSFace*)face)->setCenter(center);
+
+  return face;
+}
+
diff --git a/source/blender/freestyle/intern/winged_edge/WXEdge.h b/source/blender/freestyle/intern/winged_edge/WXEdge.h
new file mode 100755
index 00000000000..0518e70d90b
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WXEdge.h
@@ -0,0 +1,582 @@
+//
+//  Filename         : WXEdge.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Classes to define an Extended Winged Edge data structure.
+//  Date of creation : 26/10/2003
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  WXEDGE_H
+# define WXEDGE_H
+
+# include "WEdge.h"
+# include "Nature.h"
+# include "Curvature.h"
+
+typedef Nature::EdgeNature WXNature;
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXVertex           */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+class WXVertex : public WVertex
+{  
+private:
+  // Curvature info
+  CurvatureInfo *_curvatures;
+
+public:
+  inline WXVertex(const Vec3r &v)
+    : WVertex(v)
+  {_curvatures = 0;}
+  /*! Copy constructor */
+  WXVertex(WXVertex& iBrother)
+    : WVertex(iBrother)
+  {_curvatures = new CurvatureInfo(*iBrother._curvatures);}
+  virtual WVertex * duplicate()
+  {
+    WXVertex *clone = new WXVertex(*this);
+    return clone;
+  }
+  virtual ~WXVertex() {if(_curvatures) delete _curvatures;}
+  virtual void Reset() {if(_curvatures) _curvatures->Kr = 0.0;}
+  inline void setCurvatures(CurvatureInfo *ci) {_curvatures = ci;}
+  
+  inline bool isFeature();
+  inline CurvatureInfo* curvatures() {return _curvatures;}
+
+};
+
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXEdge             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+class WXEdge : public WEdge
+{
+private:
+  WXNature _nature; // flag to indicate whether the edge is a silhouette edge or not
+  int _order; // 0: the order doesn't matter. 1: the order is the orginal one. -1: the order is not good
+  bool _front;  // a front facing edge is an edge for which the bording face which is the nearest 
+                // from the viewpoint is front. A back facing edge is the opposite.
+   
+public:
+  inline WXEdge()
+    : WEdge(){
+    _nature = Nature::NO_FEATURE;
+    _front = false;
+    _order=0;
+  }
+
+  inline WXEdge(WOEdge *iOEdge)
+    : WEdge(iOEdge)
+  { _nature = Nature::NO_FEATURE;_front = false;_order=0;}
+
+  inline WXEdge(WOEdge *iaOEdge, WOEdge *ibOEdge)
+    : WEdge(iaOEdge, ibOEdge)
+  { _nature = Nature::NO_FEATURE;_front = false;_order=0;}
+
+  /*! Copy constructor */
+  inline WXEdge(WXEdge& iBrother)
+    : WEdge(iBrother)
+  {_nature = iBrother.nature();_front = iBrother._front;_order = iBrother._order;}
+  virtual WEdge * duplicate()
+  {
+    WXEdge *clone = new WXEdge(*this);
+    return clone;
+  }
+
+  virtual ~WXEdge()
+  {}
+
+  virtual void Reset(){
+    _nature  = _nature & ~Nature::SILHOUETTE;
+    _nature  = _nature & ~Nature::SUGGESTIVE_CONTOUR;
+  }
+
+  /*! accessors */
+  inline WXNature nature() {return _nature;}
+  inline bool front() {return _front;}
+  inline int order() const {return _order;}
+  
+  /*! modifiers */
+  inline void setFront(bool iFront) {_front = iFront;}
+  inline void setNature(WXNature iNature) {_nature = iNature;}
+  inline void AddNature(WXNature iNature) {_nature = _nature|iNature;}
+  inline void setOrder(int i) {_order = i;}
+  
+};
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXFace             */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+/*! Class to store a smooth edge (i.e Hertzman & Zorin smooth silhouette edges) */
+class WXSmoothEdge{
+public:
+  typedef enum{
+    EDGE_EDGE,
+    VERTEX_EDGE,
+    EDGE_VERTEX
+  } Configuration;
+
+  WOEdge *_woea; // Oriented edge from which the silhouette edge starts
+  WOEdge *_woeb; // Oriented edge where the silhouette edge ends
+  real _ta;    // The silhouette starting point's coordinates are : _woea[0]+ta*(_woea[1]-_woea[0])
+  real _tb;    // The silhouette ending point's coordinates are : _woeb[0]+ta*(_woeb[1]-_woeb[0])
+  bool _front;
+  Configuration _config;
+
+  WXSmoothEdge(){
+    _woea = 0;
+    _woeb = 0;
+    _ta = 0;
+    _tb = 0;
+    _front = false;
+    _config = EDGE_EDGE;
+  }
+  WXSmoothEdge(const WXSmoothEdge& iBrother){
+    _woea = iBrother._woea;
+    _woeb = iBrother._woeb;
+    _ta = iBrother._ta;
+    _tb = iBrother._tb;
+    _config = iBrother._config;
+    _front = iBrother._front;
+  }
+  ~WXSmoothEdge() {}
+
+  inline WOEdge * woea() {return _woea;}
+  inline WOEdge * woeb() {return _woeb;}
+  inline real ta() const {return _ta;}
+  inline real tb() const {return _tb;}
+  inline bool front() const {return _front;}
+  inline Configuration configuration() const {return _config;} 
+  
+  /*! modifiers */
+  inline void setWOeA(WOEdge *iwoea) {_woea = iwoea;}
+  inline void setWOeB(WOEdge *iwoeb) {_woeb = iwoeb;}
+  inline void setTa(real ta) {_ta = ta;}
+  inline void setTb(real tb) {_tb = tb;}
+  inline void setFront(bool iFront) {_front = iFront;}
+  inline void setConfiguration(Configuration iConf) {_config = iConf;}
+  
+};
+/* Class to store a value per vertex and a smooth edge. 
+ * The WXFace stores a list of these 
+ */
+class WXFace;
+class LIB_WINGED_EDGE_EXPORT WXFaceLayer{
+public:
+  void * userdata;
+  WXFace * _pWXFace;
+  vector<real> _DotP;// in case of silhouette: the values obtained when computing the normal-view direction 
+                         // dot product. _DotP[i] is this value for the vertex i for that 
+                          // face.
+  WXSmoothEdge * _pSmoothEdge;
+  WXNature _Nature;
+
+  //oldtmp values
+  unsigned _nPosDotP; // count the number of positive dot products for vertices.
+                      // if this number is != 0 and !=_DotP.size() -> it is a silhouette fac
+
+  unsigned _nNullDotP; // count the number of null dot products for vertices.
+  unsigned _ClosestPointIndex;
+  bool _viewDependant;
+
+  WXFaceLayer(WXFace *iFace, WXNature iNature, bool viewDependant){
+    _pWXFace = iFace;
+    _pSmoothEdge = 0;
+    _nPosDotP = 0;
+    _nNullDotP=0;
+    _Nature = iNature;
+    _viewDependant = viewDependant;
+    userdata = 0;
+  }
+  WXFaceLayer(const WXFaceLayer& iBrother){
+    _pWXFace = iBrother._pWXFace;
+    _pSmoothEdge = 0;
+    _DotP = iBrother._DotP;
+    _nPosDotP = iBrother._nPosDotP;
+    _nNullDotP = iBrother._nNullDotP;
+    _Nature = iBrother._Nature;
+    if(0 != iBrother._pSmoothEdge)
+    {
+      _pSmoothEdge = new WXSmoothEdge(*(iBrother._pSmoothEdge));
+    }
+    _viewDependant = iBrother._viewDependant;
+    userdata = 0;
+  }
+  virtual ~WXFaceLayer() {
+    if(!_DotP.empty())
+      _DotP.clear();
+    if(0 != _pSmoothEdge){
+      delete _pSmoothEdge;
+      _pSmoothEdge = 0;
+    }
+  }
+  inline const real dotP(int i) const {return _DotP[i];}
+  inline unsigned nPosDotP() const {return _nPosDotP;}
+  inline unsigned nNullDotP() const {return _nNullDotP;}
+  inline int closestPointIndex() const {return _ClosestPointIndex;}
+  inline Nature::EdgeNature nature() const {return _Nature;}
+  inline bool hasSmoothEdge() const {if(_pSmoothEdge) return true; return false;}
+  inline WXFace * getFace() {return _pWXFace;}
+  inline WXSmoothEdge * getSmoothEdge() {return _pSmoothEdge;}
+  inline bool isViewDependant() const {return _viewDependant;}
+  inline void setClosestPointIndex(int iIndex) {_ClosestPointIndex = iIndex;}
+
+  inline void removeSmoothEdge() {
+    if(!_DotP.empty())
+      _DotP.clear();
+    if (_pSmoothEdge) {
+      delete _pSmoothEdge;
+      _pSmoothEdge = 0;
+    }
+  }
+
+  /*! If one of the face layer vertex has a DotP equal
+   *  to 0, this method returns the vertex where it happens
+   */
+  unsigned int Get0VertexIndex() const ;
+
+  /*! In case one of the edge of the triangle 
+   *  is a smooth edge, this method 
+   *  allows to retrieve the concerned edge
+   */
+  unsigned int GetSmoothEdgeIndex() const;
+  /*! retrieves the edges of the triangle for which 
+   *  the signs are different (a null value is not considered) for the dotp 
+   *  values at each edge extrimity
+   */
+  void RetrieveCuspEdgesIndices(vector<int>& oCuspEdges);
+  WXSmoothEdge * BuildSmoothEdge();
+  inline void setDotP(const vector<real>& iDotP) {_DotP = iDotP;}
+  inline void PushDotP(real iDotP) {
+    _DotP.push_back(iDotP);
+    if(iDotP > 0)
+      ++_nPosDotP;
+    if(iDotP == 0)
+      ++_nNullDotP;
+  }
+  inline void ReplaceDotP(unsigned int index, real newDotP){
+    _DotP[index] = newDotP;
+    updateDotPInfos();
+  }
+  inline void updateDotPInfos() {
+    for(vector<real>::iterator d=_DotP.begin(), dend=_DotP.end();
+    d!=dend;
+    ++d){
+      _nPosDotP = 0;
+      _nNullDotP = 0;
+      if((*d) > 0)
+        ++_nPosDotP;
+      if((*d) == 0)
+        ++_nNullDotP;
+    }
+  }
+};
+
+
+class WXFace : public WFace
+{
+protected:
+  Vec3r _center; // center of the face
+  real _Z; // distance from viewpoint to the center of the face
+  bool _front; // flag to tell whether the face is front facing or back facing
+  real _dotp;  // value obtained when computing the normal-viewpoint dot product
+ 
+  vector<WXFaceLayer*> _SmoothLayers; // The data needed to store one or several smooth edges that traverse the face
+public:
+  inline WXFace() : WFace() {_Z=0.0;_front = false;}
+  /*! Copy constructor */
+  WXFace(WXFace& iBrother)
+    : WFace(iBrother)
+  {
+    _center = iBrother.center();
+    _Z = iBrother.Z();
+    _front = iBrother.front();
+    for(vector<WXFaceLayer*>::iterator wxf = iBrother._SmoothLayers.begin(), wxfend = iBrother._SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      _SmoothLayers.push_back(new WXFaceLayer(**wxf));
+    }
+  }
+  virtual WFace * duplicate()
+  {
+    WXFace * clone = new WXFace(*this);
+    return clone;
+  }
+
+  virtual ~WXFace() {
+    if(!_SmoothLayers.empty()){
+      for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+      wxf != wxfend;
+      ++wxf){
+        delete (*wxf);
+      }
+      _SmoothLayers.clear();
+    } 
+  }
+
+  /*! designed to build a specialized WEdge 
+   *  for use in MakeEdge
+   */
+  virtual WEdge * instanciateEdge() const {return new WXEdge;}
+  
+  /*! accessors */
+  inline Vec3r& center() {return _center;}
+  inline real Z() {return _Z;}
+  inline bool front() {return _front;}
+  inline real dotp() {return _dotp;}
+  inline bool hasSmoothEdges() const {
+    for(vector<WXFaceLayer*>::const_iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      if( ((*wxf)->hasSmoothEdge())){
+        return true;
+      }
+    }
+    return false;
+  }
+  vector<WXFaceLayer*>& getSmoothLayers() {return _SmoothLayers;}
+  /*! retrieve the smooth edges that match the Nature given as argument */
+  void retrieveSmoothEdges(WXNature iNature, vector<WXSmoothEdge*>& oSmoothEdges){
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      if( ((*wxf)->hasSmoothEdge()) && ((*wxf)->_Nature & iNature) ){
+        oSmoothEdges.push_back((*wxf)->_pSmoothEdge);
+      }
+    }
+  }
+  void retrieveSmoothEdgesLayers(WXNature iNature, vector<WXFaceLayer*>& oSmoothEdgesLayers){
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      if( ((*wxf)->hasSmoothEdge()) && ((*wxf)->_Nature & iNature) ){
+        oSmoothEdgesLayers.push_back((*wxf));
+      }
+    }
+  }
+  void retrieveSmoothLayers(WXNature iNature, vector<WXFaceLayer*>& oSmoothLayers){
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      if((*wxf)->_Nature & iNature){
+        oSmoothLayers.push_back(*wxf);
+      }
+    }
+  }
+  /*! modifiers */
+  inline void setCenter(const Vec3r& iCenter) {_center = iCenter;}
+  void ComputeCenter();
+  inline void setZ(real z) {_Z = z;}
+  inline void setFront(bool iFront) {_front = iFront;}
+  inline void setDotP(real iDotP) 
+  {
+    _dotp = iDotP;
+    if(_dotp > 0)
+      _front = true;
+    else
+      _front = false;
+  }
+  inline void AddSmoothLayer(WXFaceLayer * iLayer){
+    _SmoothLayers.push_back(iLayer);
+  }
+  inline void Reset() {
+    vector<WXFaceLayer*> layersToKeep;
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      if((*wxf)->isViewDependant())
+        delete (*wxf);
+      else
+        layersToKeep.push_back(*wxf);
+    }
+    _SmoothLayers = layersToKeep;
+  }
+  /*! Clears everything */
+  inline void Clear() {
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      delete (*wxf);
+    }
+    _SmoothLayers.clear();
+  }
+  virtual void ResetUserData() {
+    WFace::ResetUserData();
+    for(vector<WXFaceLayer*>::iterator wxf = _SmoothLayers.begin(), wxfend = _SmoothLayers.end();
+    wxf != wxfend;
+    ++wxf){
+      (*wxf)->userdata = 0;
+    }
+  }
+};
+
+
+                  /**********************************/
+                  /*                                */
+                  /*                                */
+                  /*             WXShape            */
+                  /*                                */
+                  /*                                */
+                  /**********************************/
+
+
+class WXShape : public WShape
+{
+public:
+  typedef WXShape type_name;
+protected:
+  bool _computeViewIndependant; // flag to indicate whether the view independant stuff must be computed or not
+public:
+  inline WXShape() : WShape() {_computeViewIndependant = true;}
+  /*! copy constructor */
+  inline WXShape(WXShape& iBrother)
+    :WShape(iBrother)
+  {
+    _computeViewIndependant = iBrother._computeViewIndependant;
+  }
+  virtual WShape * duplicate()
+  {
+    WXShape *clone = new WXShape(*this);
+    return clone;
+  }
+  
+  virtual ~WXShape()
+  {
+  }
+ 
+  inline bool getComputeViewIndependantFlag() const {return _computeViewIndependant;}
+  inline void setComputeViewIndependantFlag(bool iFlag) {_computeViewIndependant = iFlag;}
+
+  /*! designed to build a specialized WFace 
+   *  for use in MakeFace
+   */
+  virtual WFace * instanciateFace() const {return new WXFace;}
+
+ /*! adds a new face to the shape 
+  *  returns the built face.
+  *   iVertexList 
+  *      List of face's vertices. These vertices are 
+  *      not added to the WShape vertex list; they are 
+  *      supposed to be already stored when calling MakeFace.
+  *      The order in which the vertices are stored in the list 
+  *      determines the face's edges orientation and (so) the 
+  *      face orientation.
+  */
+  virtual WFace * MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterialIndex);
+
+  /*! adds a new face to the shape. The difference with 
+   *  the previous method is that this one is designed 
+   *  to build a WingedEdge structure for which there are 
+   *  per vertex normals, opposed to per face normals.
+   *  returns the built face.
+   *   iVertexList 
+   *      List of face's vertices. These vertices are 
+   *      not added to the WShape vertex list; they are 
+   *      supposed to be already stored when calling MakeFace.
+   *      The order in which the vertices are stored in the list 
+   *      determines the face's edges orientation and (so) the 
+   *      face orientation.
+   *   iNormalsList
+   *     The list of normals, iNormalsList[i] corresponding to the 
+   *     normal of the vertex iVertexList[i] for that face.
+   *   iTexCoordsList
+   *     The list of tex coords, iTexCoordsList[i] corresponding to the 
+   *     normal of the vertex iVertexList[i] for that face.
+   */
+  virtual WFace * MakeFace(vector<WVertex*>& iVertexList, vector<Vec3r>& iNormalsList, vector<Vec2r>& iTexCoordsList, unsigned iMaterialIndex);
+
+  /*! Reset all edges and vertices flags (which might
+   *  have been set up on a previous pass)
+   */
+  virtual void Reset(){
+    // Reset Edges
+    vector<WEdge*>& wedges = GetEdgeList();
+    for(vector<WEdge*>::iterator we=wedges.begin(),weend=wedges.end();
+    we!=weend;
+    we++){
+      ((WXEdge*)(*we))->Reset();
+    }
+
+    //Reset faces:
+    vector<WFace*>& wfaces = GetFaceList();
+    for(vector<WFace*>::iterator wf=wfaces.begin(),wfend=wfaces.end();
+    wf!=wfend;
+    wf++){
+      ((WXFace*)(*wf))->Reset();
+    }
+  }
+  /*! accessors */
+};
+
+/*
+  
+  #############################################
+  #############################################
+  #############################################
+  ######                                 ######
+  ######   I M P L E M E N T A T I O N   ######
+  ######                                 ######
+  #############################################
+  #############################################
+  #############################################
+  
+*/
+/* for inline functions */
+
+bool WXVertex::isFeature() 
+{ 
+  int counter = 0;
+  vector<WEdge*>& vedges = GetEdges();
+  for(vector<WEdge*>::iterator ve=vedges.begin(), vend=vedges.end();
+  ve!=vend;
+  ve++)
+  {
+    if(((WXEdge*)(*ve))->nature() != Nature::NO_FEATURE)
+      counter++;
+  }
+  
+  if((counter == 1) || (counter > 2))
+    return true;
+  
+  return false;
+}
+
+
+#endif
diff --git a/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp b/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp
new file mode 100755
index 00000000000..9d22b4f8db5
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp
@@ -0,0 +1,43 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "WXEdgeBuilder.h"
+#include "WXEdge.h"
+
+void WXEdgeBuilder::visitIndexedFaceSet(IndexedFaceSet& ifs)
+{
+  WXShape *shape = new WXShape;
+  buildWShape(*shape, ifs);
+  shape->setId(ifs.getId().getFirst());
+  //ifs.setId(shape->GetId());
+}
+
+void WXEdgeBuilder::buildWVertices(WShape& shape,
+			       const real *vertices,
+			       unsigned vsize) {
+  WXVertex *vertex;
+  for (unsigned i = 0; i < vsize; i += 3) {
+    vertex = new WXVertex(Vec3r(vertices[i],
+				      vertices[i + 1],
+				      vertices[i + 2]));
+    vertex->setId(i / 3);
+    shape.AddVertex(vertex);
+  }
+}
diff --git a/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h b/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h
new file mode 100755
index 00000000000..b646d66a285
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h
@@ -0,0 +1,51 @@
+#ifndef WXEDGEBUILDER_H
+# define WXEDGEBUILDER_H
+
+//
+//  Filename         : WSBuilder.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class inherited from WingedEdgeBuilder and 
+//                     designed to build a WX (WingedEdge + extended info(silhouette etc...)) 
+//                     structure from a polygonal model
+//  Date of creation : 28/05/03
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+# include "WingedEdgeBuilder.h"
+# include "../scene_graph/IndexedFaceSet.h"
+
+class LIB_WINGED_EDGE_EXPORT WXEdgeBuilder : public WingedEdgeBuilder
+{
+public:
+	WXEdgeBuilder() : WingedEdgeBuilder() {}
+  virtual ~WXEdgeBuilder() {}
+  VISIT_DECL(IndexedFaceSet)
+
+protected:
+  virtual void buildWVertices(WShape& shape,
+			      const real *vertices,
+			      unsigned vsize);
+};
+
+#endif // WXEDGEBUILDER_H
diff --git a/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp b/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp
new file mode 100755
index 00000000000..c95231a72dc
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp
@@ -0,0 +1,362 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../geometry/GeomUtils.h"
+#include "../scene_graph/NodeShape.h"
+#include "WingedEdgeBuilder.h"
+#include <set>
+using namespace std;
+
+void WingedEdgeBuilder::visitIndexedFaceSet(IndexedFaceSet& ifs) {
+  WShape *shape = new WShape;
+  buildWShape(*shape, ifs);
+  shape->setId(ifs.getId().getFirst());
+  //ifs.setId(shape->GetId());
+}
+
+void WingedEdgeBuilder::visitNodeShape(NodeShape& ns) {
+  //Sets the current material to iShapeode->material:
+  _current_material = &(ns.material());
+}
+
+void WingedEdgeBuilder::visitNodeTransform(NodeTransform& tn) {
+  if(!_current_matrix) {
+    _current_matrix = new Matrix44r(tn.matrix());
+    return;
+  }
+
+  _matrices_stack.push_back(_current_matrix);
+  Matrix44r *new_matrix = new Matrix44r(*_current_matrix * tn.matrix());
+  _current_matrix = new_matrix;
+}
+
+void WingedEdgeBuilder::visitNodeTransformAfter(NodeTransform&) {
+  if(_current_matrix)
+    delete _current_matrix;
+
+  if(_matrices_stack.empty()) {
+    _current_matrix = NULL;
+    return;
+  }
+
+  _current_matrix = _matrices_stack.back();
+  _matrices_stack.pop_back();
+}
+
+void WingedEdgeBuilder::buildWShape(WShape& shape, IndexedFaceSet& ifs) {
+  unsigned	vsize = ifs.vsize();
+  unsigned	nsize = ifs.nsize();
+  //soc unused - unsigned	tsize = ifs.tsize();
+
+  const real*	vertices = ifs.vertices();
+  const real*	normals = ifs.normals();
+  const real*	texCoords = ifs.texCoords();
+
+  real*		new_vertices;
+  real*		new_normals;
+
+	new_vertices = new real[vsize];
+	new_normals = new real[nsize];
+
+  // transform coordinates from local to world system
+  if(_current_matrix) {
+    transformVertices(vertices, vsize, *_current_matrix, new_vertices);
+    transformNormals(normals, nsize, *_current_matrix, new_normals);
+  }
+  else {
+    memcpy(new_vertices, vertices, vsize * sizeof(*new_vertices));
+    memcpy(new_normals, normals, nsize * sizeof(*new_normals));
+  }
+
+  const IndexedFaceSet::TRIANGLES_STYLE*	faceStyle = ifs.trianglesStyle();
+
+	vector<Material> materials;
+	if(ifs.msize()){
+		const Material*const* mats = ifs.materials();
+		for(unsigned i=0; i<ifs.msize(); ++i)
+			materials.push_back(*(mats[i]));
+		shape.setMaterials(materials);
+	}
+
+  //  const Material * mat = (ifs.material());
+  //  if (mat)
+  //    shape.setMaterial(*mat);
+  //  else if(_current_material)
+  //    shape.setMaterial(*_current_material);
+
+  // sets the current WShape to shape
+  _current_wshape = &shape;
+
+  // create a WVertex for each vertex
+  buildWVertices(shape, new_vertices, vsize);
+  
+  const unsigned*	vindices = ifs.vindices();
+  const unsigned*	nindices = ifs.nindices();
+  const unsigned*	tindices = 0;
+  if(ifs.tsize()){
+      tindices = ifs.tindices();
+  }
+  
+	const unsigned *mindices = 0;
+	if(ifs.msize())
+		mindices = ifs.mindices();
+	const unsigned*	numVertexPerFace = ifs.numVertexPerFaces();
+  const unsigned	numfaces = ifs.numFaces();
+
+  for (unsigned index = 0; index < numfaces; index++) {
+    switch(faceStyle[index]) {
+    case IndexedFaceSet::TRIANGLE_STRIP:
+      buildTriangleStrip(new_vertices,
+			 new_normals,
+       materials,
+       texCoords,
+			 vindices,
+			 nindices,
+       mindices,
+       tindices,
+			 numVertexPerFace[index]);
+      break;
+    case IndexedFaceSet::TRIANGLE_FAN:
+      buildTriangleFan(new_vertices,
+		       new_normals,
+           materials, 
+           texCoords,
+		       vindices,
+		       nindices,
+           mindices,
+           tindices,
+		       numVertexPerFace[index]);
+      break;
+    case IndexedFaceSet::TRIANGLES:
+      buildTriangles(new_vertices,
+		     new_normals,
+         materials,
+         texCoords,
+		     vindices,
+		     nindices,
+         mindices,
+         tindices,
+		     numVertexPerFace[index]);
+      break;
+    }
+    vindices += numVertexPerFace[index];
+    nindices += numVertexPerFace[index];
+		if(mindices)
+			mindices += numVertexPerFace[index];
+    if(tindices)
+        tindices += numVertexPerFace[index];
+  }
+
+  delete[] new_vertices;
+  delete[] new_normals;
+
+  // compute bbox
+  shape.ComputeBBox();
+  // compute mean edge size:
+  shape.ComputeMeanEdgeSize();
+
+  // Parse the built winged-edge shape to update post-flags
+  set<Vec3r> normalsSet;
+  vector<WVertex*>& wvertices = shape.GetVertexList();
+  for(vector<WVertex*>::iterator wv=wvertices.begin(), wvend=wvertices.end();
+  wv!=wvend;
+  ++wv){
+    if((*wv)->isBoundary())
+      continue;
+    normalsSet.clear();
+    WVertex::face_iterator fit = (*wv)->faces_begin();
+    WVertex::face_iterator fitend = (*wv)->faces_end();
+    while(fit!=fitend){
+      WFace *face = *fit;
+      normalsSet.insert(face->GetVertexNormal(*wv));
+      if(normalsSet.size()!=1){
+        break;
+      }
+      ++fit;
+    }
+    if(normalsSet.size()!=1){
+      (*wv)->setSmooth(false);
+    }
+  }
+  // Adds the new WShape to the WingedEdge structure
+  _winged_edge->addWShape(&shape);
+}
+
+void WingedEdgeBuilder::buildWVertices(WShape& shape,
+				       const real *vertices,
+				       unsigned vsize) {
+  WVertex *vertex;
+  for (unsigned i = 0; i < vsize; i += 3) {
+    vertex = new WVertex(Vec3r(vertices[i],
+			       vertices[i + 1],
+			       vertices[i + 2]));
+    vertex->setId(i / 3);
+    shape.AddVertex(vertex);
+  }
+}
+
+void WingedEdgeBuilder::buildTriangleStrip( const real *vertices, 
+			                                      const real *normals, 
+                                           vector<Material>& iMaterials, 
+                                           const real *texCoords, 
+			                                      const unsigned *vindices, 
+			                                      const unsigned *nindices,
+                                            const unsigned *mindices,
+                                            const unsigned *tindices,
+			                                      const unsigned nvertices) {
+  unsigned nDoneVertices = 2; // number of vertices already treated
+  unsigned nTriangle = 0;     // number of the triangle currently being treated
+  //int nVertex = 0;       // vertex number
+
+  WShape* currentShape = _current_wshape; // the current shape being built
+  vector<WVertex *> triangleVertices;
+  vector<Vec3r> triangleNormals;
+  vector<Vec2r> triangleTexCoords;
+
+  while(nDoneVertices < nvertices)
+  { 
+    //clear the vertices list:
+    triangleVertices.clear();
+    //Then rebuild it:
+    if(0 == nTriangle%2) // if nTriangle is even
+    {
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle]/3]);
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle+1]/3]);
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle+2]/3]);
+
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle]],normals[nindices[nTriangle]+1], normals[nindices[nTriangle]+2]));
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle+1]],normals[nindices[nTriangle+1]+1],normals[nindices[nTriangle+1]+2]));
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle+2]], normals[nindices[nTriangle+2]+1], normals[nindices[nTriangle+2]+2]));
+
+      if(texCoords){
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle]],texCoords[tindices[nTriangle]+1]));
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle+1]],texCoords[tindices[nTriangle+1]+1]));
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle+2]], texCoords[tindices[nTriangle+2]+1]));
+      }
+    }
+    else                 // if nTriangle is odd
+    {
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle]/3]);
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle+2]/3]);
+      triangleVertices.push_back(currentShape->GetVertexList()[vindices[nTriangle+1]/3]);
+
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle]],normals[nindices[nTriangle]+1], normals[nindices[nTriangle]+2]));
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle+2]],normals[nindices[nTriangle+2]+1],normals[nindices[nTriangle+2]+2]));
+      triangleNormals.push_back(Vec3r(normals[nindices[nTriangle+1]], normals[nindices[nTriangle+1]+1], normals[nindices[nTriangle+1]+2]));
+
+      if(texCoords){
+          triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle]],texCoords[tindices[nTriangle]+1]));
+          triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle+2]],texCoords[tindices[nTriangle+2]+1]));
+          triangleTexCoords.push_back(Vec2r(texCoords[tindices[nTriangle+1]], texCoords[tindices[nTriangle+1]+1]));
+      }
+    }
+		if(mindices)
+			currentShape->MakeFace(triangleVertices, triangleNormals, triangleTexCoords, mindices[nTriangle/3]);
+		else
+			currentShape->MakeFace(triangleVertices, triangleNormals, triangleTexCoords, 0);
+    nDoneVertices++; // with a strip, each triangle is one vertex more
+    nTriangle++;
+  }
+}
+
+void WingedEdgeBuilder::buildTriangleFan( const real *vertices, 
+			                                      const real *normals, 
+                                            vector<Material>&  iMaterials, 
+                                            const real *texCoords, 
+			                                      const unsigned *vindices, 
+			                                      const unsigned *nindices,
+                                            const unsigned *mindices,
+                                            const unsigned *tindices,
+			                                      const unsigned nvertices) {
+  // Nothing to be done
+}
+
+void WingedEdgeBuilder::buildTriangles(const real *vertices, 
+			                                      const real *normals, 
+                                            vector<Material>&  iMaterials, 
+                                            const real *texCoords, 
+			                                      const unsigned *vindices, 
+			                                      const unsigned *nindices,
+                                            const unsigned *mindices,
+                                            const unsigned *tindices,
+			                                      const unsigned nvertices) {
+  WShape * currentShape = _current_wshape; // the current shape begin built
+  vector<WVertex *> triangleVertices;
+  vector<Vec3r> triangleNormals;
+  vector<Vec2r> triangleTexCoords;
+
+  // Each triplet of vertices is considered as an independent triangle
+  for(unsigned i = 0; i < nvertices / 3; i++)
+  {
+    triangleVertices.push_back(currentShape->GetVertexList()[vindices[3*i]/3]);
+    triangleVertices.push_back(currentShape->GetVertexList()[vindices[3*i+1]/3]);
+    triangleVertices.push_back(currentShape->GetVertexList()[vindices[3*i+2]/3]);
+
+    triangleNormals.push_back(Vec3r(normals[nindices[3*i]],normals[nindices[3*i]+1], normals[nindices[3*i]+2]));
+    triangleNormals.push_back(Vec3r(normals[nindices[3*i+1]],normals[nindices[3*i+1]+1],normals[nindices[3*i+1]+2]));
+    triangleNormals.push_back(Vec3r(normals[nindices[3*i+2]], normals[nindices[3*i+2]+1], normals[nindices[3*i+2]+2]));
+
+    if(texCoords){
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[3*i]],texCoords[tindices[3*i]+1]));
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[3*i+1]],texCoords[tindices[3*i+1]+1]));
+        triangleTexCoords.push_back(Vec2r(texCoords[tindices[3*i+2]], texCoords[tindices[3*i+2]+1]));
+    }
+  }
+	if(mindices)
+		currentShape->MakeFace(triangleVertices, triangleNormals, triangleTexCoords, mindices[0]);
+	else
+		currentShape->MakeFace(triangleVertices, triangleNormals, triangleTexCoords,0);
+  
+}
+
+void WingedEdgeBuilder::transformVertices(const real *vertices,
+					  unsigned vsize, 
+					  const Matrix44r& transform,
+					  real *res) {
+  const real *v = vertices;
+  real *pv = res;
+    
+  for (unsigned i = 0; i < vsize / 3; i++) {
+    HVec3r hv_tmp(v[0], v[1], v[2]);
+    HVec3r hv(transform * hv_tmp);
+    for (unsigned j = 0; j < 3; j++)
+      pv[j] = hv[j] / hv[3];
+    v += 3;
+    pv += 3;
+  }
+}
+
+void WingedEdgeBuilder::transformNormals(const real *normals,
+					 unsigned nsize,
+					 const Matrix44r& transform,
+					 real* res) {
+  const real *n = normals;
+  real *pn = res;
+    
+  for (unsigned i = 0; i < nsize / 3; i++) {
+    Vec3r hn(n[0], n[1], n[2]);
+    hn = GeomUtils::rotateVector(transform, hn);
+    for (unsigned j = 0; j < 3; j++)
+      pn[j] = hn[j];
+    n += 3;
+    pn += 3;
+  }
+}
diff --git a/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h b/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h
new file mode 100755
index 00000000000..fe033f2ea0b
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h
@@ -0,0 +1,160 @@
+//
+//  Filename         : WingedEdgeBuilder.h
+//  Author(s)        : Stephane Grabli
+//  Purpose          : Class to render a WingedEdge data structure
+//                     from a polyhedral data structure organized in
+//                     nodes of a scene graph
+//  Date of creation : 28/05/03
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef  WINGED_EDGE_BUILDER_H
+# define WINGED_EDGE_BUILDER_H
+
+# include "../system/FreestyleConfig.h"
+# include "../scene_graph/SceneVisitor.h"
+# include "WEdge.h"
+# include "../scene_graph/IndexedFaceSet.h"
+# include "../scene_graph/NodeTransform.h"
+
+class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
+{
+ public:
+
+  inline WingedEdgeBuilder() : SceneVisitor() {
+    _current_wshape = NULL;
+    _current_material = NULL;
+    _current_matrix = NULL;
+    _winged_edge = new WingedEdge; // Not deleted by the destructor
+  }
+
+  virtual ~WingedEdgeBuilder() {
+    for (vector<Matrix44r*>::iterator it = _matrices_stack.begin();
+	 it != _matrices_stack.end();
+	 it++)
+      delete *it;
+    _matrices_stack.clear();
+  }
+
+  VISIT_DECL(IndexedFaceSet)
+  VISIT_DECL(NodeShape)
+  VISIT_DECL(NodeTransform)
+
+  virtual void visitNodeTransformAfter(NodeTransform&);
+
+  //
+  // Accessors
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  inline WingedEdge*	getWingedEdge() {
+    return _winged_edge;
+  }
+
+  inline WShape*	getCurrentWShape() {
+    return _current_wshape;
+  }
+ 
+  inline Material*	getCurrentMaterial() {
+    return _current_material;
+  }
+
+  inline Matrix44r*	getCurrentMatrix() {
+    return _current_matrix;
+  }
+
+  //
+  // Modifiers
+  //
+  /////////////////////////////////////////////////////////////////////////////
+
+  inline void setCurrentWShape(WShape* wshape) {
+    _current_wshape = wshape;
+  }
+
+  inline void setCurrentMaterial(Material* mat) {
+    _current_material = mat;
+  }
+
+  //  inline void setCurrentMatrix(Matrix44r* matrix) {
+  //    _current_matrix = matrix;
+  //  }
+
+ protected:
+
+  virtual void buildWShape(WShape& shape, IndexedFaceSet& ifs);
+  virtual void buildWVertices(WShape& shape,
+			      const real *vertices,
+			      unsigned vsize);
+
+ private:
+
+  void buildTriangleStrip(const real *vertices, 
+			  const real *normals, 
+        vector<Material>&  iMaterials, 
+        const real *texCoords,
+			  const unsigned *vindices, 
+			  const unsigned *nindices,
+        const unsigned *mindices,
+        const unsigned *tindices,
+			  const unsigned nvertices);
+
+  void buildTriangleFan(const real *vertices, 
+			const real *normals, 
+      vector<Material>&  iMaterials,
+      const real *texCoords,
+			const unsigned *vindices, 
+			const unsigned *nindices,
+      const unsigned *mindices,
+      const unsigned *tindices,
+			const unsigned nvertices);
+
+  void buildTriangles(const real *vertices, 
+		      const real *normals, 
+          vector<Material>&  iMaterials,
+          const real *texCoords,
+		      const unsigned *vindices, 
+		      const unsigned *nindices,
+          const unsigned *mindices,
+          const unsigned *tindices,
+		      const unsigned nvertices);
+
+  void transformVertices(const real *vertices,
+			 unsigned vsize, 
+			 const Matrix44r& transform,
+			 real *res);
+
+  void transformNormals(const real *normals,
+			unsigned nsize,
+			const Matrix44r& transform,
+			real *res);
+ 
+  WShape*		_current_wshape;
+  Material*		_current_material;
+  WingedEdge*		_winged_edge;
+  Matrix44r*		_current_matrix;
+  vector<Matrix44r*>	_matrices_stack;
+};
+
+#endif // WINGED_EDGE_BUILDER_H
diff --git a/source/blender/freestyle/intern/winged_edge/src.pri b/source/blender/freestyle/intern/winged_edge/src.pri
new file mode 100755
index 00000000000..9cf40633dcf
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/src.pri
@@ -0,0 +1,21 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+WINGED_EDGE_DIR = ../winged_edge
+
+SOURCES *= $${WINGED_EDGE_DIR}/Curvature.cpp \
+	   $${WINGED_EDGE_DIR}/WEdge.cpp \
+	   $${WINGED_EDGE_DIR}/WFillGrid.cpp \       
+	   $${WINGED_EDGE_DIR}/WingedEdgeBuilder.cpp \
+	   $${WINGED_EDGE_DIR}/WXEdgeBuilder.cpp \
+	   $${WINGED_EDGE_DIR}/WXEdge.cpp 
+
+HEADERS *= $${WINGED_EDGE_DIR}/Curvature.h \
+	   $${WINGED_EDGE_DIR}/Nature.h \
+	   $${WINGED_EDGE_DIR}/WEdge.h \
+	   $${WINGED_EDGE_DIR}/WFillGrid.h \
+	   $${WINGED_EDGE_DIR}/WingedEdgeBuilder.h \
+	   $${WINGED_EDGE_DIR}/WXEdgeBuilder.h \
+	   $${WINGED_EDGE_DIR}/WXEdge.h    
diff --git a/source/blender/freestyle/intern/winged_edge/winged_edge.pro b/source/blender/freestyle/intern/winged_edge/winged_edge.pro
new file mode 100755
index 00000000000..e36d69454b6
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/winged_edge.pro
@@ -0,0 +1,84 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+include(../Config.pri)
+
+TEMPLATE        = lib
+
+TARGET          = $${LIB_WINGED_EDGE}
+VERSION         = $${APPVERSION}
+TARGET_VERSION_EXT = $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG          *= dll
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES   *= MAKE_LIB_WINGED_EDGE_DLL
+
+#
+# INCLUDE PATH
+#
+#######################################
+
+#INCLUDEPATH     *= ../geometry ../scene_graph ../system
+
+#
+# BUILD DIRECTORIES
+#
+#######################################
+
+BUILD_DIR       = ../../build
+
+OBJECTS_DIR     = $${BUILD_DIR}/$${REL_OBJECTS_DIR}
+!win32:DESTDIR  = $${BUILD_DIR}/$${REL_DESTDIR}/lib
+win32:DESTDIR   = $${BUILD_DIR}/$${REL_DESTDIR}
+
+#
+# LIBS
+#
+#######################################
+
+win32:LIBS      *= $${DESTDIR}/$${LIB_GEOMETRY}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SCENE_GRAPH}$${LIBVERSION}.lib \
+                   $${DESTDIR}/$${LIB_SYSTEM}$${LIBVERSION}.lib
+!win32 {
+  lib_bundle {
+    LIBS += -F$${DESTDIR} -framework $${LIB_GEOMETRY} \
+	    -framework $${LIB_SYSTEM} -framework $${LIB_SCENE_GRAPH}
+  } else {
+    LIBS += -L$${DESTDIR} -l$${LIB_GEOMETRY} -l$${LIB_SCENE_GRAPH} -l$${LIB_SYSTEM}
+  }
+}
+
+
+#
+# INSTALL
+#
+#######################################
+
+LIB_DIR       = ../../lib
+# install library
+target.path   = $$LIB_DIR
+# "make install" configuration options
+INSTALLS     += target
+
+#
+# SOURCES & HEADERS
+#
+#######################################
+
+!static {
+  include(src.pri)
+}
diff --git a/source/blender/freestyle/misc/AUTHORS.TXT b/source/blender/freestyle/misc/AUTHORS.TXT
new file mode 100755
index 00000000000..27cdb70d5ec
--- /dev/null
+++ b/source/blender/freestyle/misc/AUTHORS.TXT
@@ -0,0 +1,6 @@
+Authors
+-------
+Frédo Durand		<fredo@mit.edu>
+Stéphane Grabli		<stephane.grabli@imag.fr>
+François Sillion	<francois.sillion@imag.fr>
+Emmanuel Turquin	<emmanuel.turquin@imag.fr>
diff --git a/source/blender/freestyle/misc/BUGS.TXT b/source/blender/freestyle/misc/BUGS.TXT
new file mode 100755
index 00000000000..c5bad029a47
--- /dev/null
+++ b/source/blender/freestyle/misc/BUGS.TXT
@@ -0,0 +1,11 @@
+* Application doesn't exit properly (eg style window still hangs out)
+* macosx: Window bar is unaccessible.
+* macosx: Build leds to an application that is half-bundle (for the executable) half UNIX-style (for libraries).
+* Strokes Strips are sometimes incorrect
+* TVertex sometimes points towards NULL ViewEdges
+* Some points are found to be outside of the grid. (for big models and mostly in release mode). Probably due to precision problems.
+* Operators::recursiveChains() and ViewEdgeIterator change ViewEdgeIterator so that it supports the copy of specialized types in a transparent way. It works here only because we're never copying it and because it is passed as a reference.
+* Functions0D takes a Interface0DIterator& insted of a const Interface0DIterator& as argument. dangerous.
+* crashes on big models
+
+ 
diff --git a/source/blender/freestyle/misc/COPYRIGHT.TXT b/source/blender/freestyle/misc/COPYRIGHT.TXT
new file mode 100755
index 00000000000..cd37bd16786
--- /dev/null
+++ b/source/blender/freestyle/misc/COPYRIGHT.TXT
@@ -0,0 +1,9 @@
+Freestyle
+
+Copyright (c) 2001-2007 by the following:
+
+
+Frédo Durand		<fredo@mit.edu>
+Stéphane Grabli		<stephane.grabli@gmail.com>
+François Sillion	<francois.sillion@imag.fr>
+Emmanuel Turquin	<emmanuel.turquin@imag.fr>
diff --git a/source/blender/freestyle/misc/Config.pri b/source/blender/freestyle/misc/Config.pri
new file mode 100755
index 00000000000..68763dba502
--- /dev/null
+++ b/source/blender/freestyle/misc/Config.pri
@@ -0,0 +1,176 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#                 A p p l i c a t i o n   &   L i b r a r i e s               #
+#                    b u i l d    c o n f i g u r a t i o n                   #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+#
+# APPLICATION
+#
+#######################################
+
+APPNAME         = Freestyle
+APPVERSION_MAJ  = 2
+APPVERSION_MID  = 2
+APPVERSION_MIN  = 0
+APPVERSION      = $${APPVERSION_MAJ}.$${APPVERSION_MID}.$${APPVERSION_MIN}
+
+PYTHON_VERSION_MAJ = 2
+PYTHON_VERSION_MIN = 5
+
+LIB3DS_VERSION_MAJ = 1
+LIB3DS_VERSION_MIN = 30
+
+#
+# CONFIG
+#
+#######################################
+
+CONFIG		-= debug release ReleaseBuild Release build_pass precompile_header debug_and_release debug_and_release_target
+CONFIG            *= qt shared stl exceptions rtti thread
+CONFIG                  *= release # debug or release
+CONFIG                  *= warn_off # warn_off or warn_on
+mac:CONFIG 		+= x86
+#mac:CONFIG		+= ppc
+#mac:CONFIG		*= lib_bundle
+
+#mac:QMAKE_MAC_SDK = /Developer/SDKs/MacOSX10.4u.sdk
+#message($$CONFIG)
+#CONFIG                  *= static
+#CONFIG                  *= profiling
+
+
+
+QT += opengl
+
+#
+# LIBRARIES
+#
+#######################################
+
+debug{
+	LIB_GEOMETRY     = $${APPNAME}Geometry_d
+	LIB_IMAGE        = $${APPNAME}Image_d
+	LIB_RENDERING    = $${APPNAME}Rendering_d
+	LIB_SCENE_GRAPH  = $${APPNAME}SceneGraph_d
+	LIB_SYSTEM       = $${APPNAME}System_d
+	LIB_VIEW_MAP     = $${APPNAME}ViewMap_d
+	LIB_STROKE       = $${APPNAME}Stroke_d
+	LIB_WINGED_EDGE  = $${APPNAME}WingedEdge_d
+}else{
+	LIB_GEOMETRY     = $${APPNAME}Geometry
+	LIB_IMAGE        = $${APPNAME}Image
+	LIB_RENDERING    = $${APPNAME}Rendering
+	LIB_SCENE_GRAPH  = $${APPNAME}SceneGraph
+	LIB_SYSTEM       = $${APPNAME}System
+	LIB_VIEW_MAP     = $${APPNAME}ViewMap
+	LIB_STROKE       = $${APPNAME}Stroke
+	LIB_WINGED_EDGE  = $${APPNAME}WingedEdge
+}
+
+LIBVERSION	= $${APPVERSION_MAJ}.$${APPVERSION_MID}
+
+
+#
+# FLAGS
+#
+#######################################
+
+win32:QMAKE_CXXFLAGS     *= /GR /GX
+win32:QMAKE_CFLAGS       *= /GR /GX
+irix-n32:QMAKE_CFLAGS    *= -LANG:std
+irix-n32:QMAKE_CXXFLAGS  *= -LANG:std
+linux-g++:QMAKE_CFLAGS   *= -Wno-deprecated
+linux-g++:QMAKE_CXXFLAGS *= -Wno-deprecated
+cygwin-g++:QMAKE_CFLAGS   *= -Wno-deprecated
+cygwin-g++:QMAKE_CXXFLAGS *= -Wno-deprecated -mno-win32
+mac:QMAKE_CFLAGS         *= -Wno-deprecated
+mac:QMAKE_CXXFLAGS       *= -Wno-deprecated
+
+linux-g++:QMAKE_CFLAGS_RELEASE   = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+linux-g++:QMAKE_CXXFLAGS_RELEASE = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+cygwin-g++:QMAKE_CFLAGS_RELEASE   = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+cygwin-g++:QMAKE_CXXFLAGS_RELEASE = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+mac:QMAKE_CFLAGS_RELEASE         = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+mac:QMAKE_CXXFLAGS_RELEASE       = -O3 -funroll-loops -fomit-frame-pointer -ffast-math -march=i686
+
+profiling {
+  linux-g++:QMAKE_CFLAGS_DEBUG   = -pg
+  linux-g++:QMAKE_CXXFLAGS_DEBUG = -pg
+  linux-g++:QMAKE_LFLAGS_DEBUG   = -pg
+  cygwin-g++:QMAKE_CFLAGS_DEBUG   = -pg
+  cygwin-g++:QMAKE_CXXFLAGS_DEBUG = -pg
+  cygwin-g++:QMAKE_LFLAGS_DEBUG   = -pg
+  mac:QMAKE_CFLAGS_DEBUG         = -pg
+  mac:QMAKE_CXXFLAGS_DEBUG       = -pg
+  mac:QMAKE_LFLAGS_DEBUG         = -pg
+}
+
+#
+# DEFINES
+#
+#######################################
+
+win32:DEFINES           *= WIN32 QT_DLL QT_THREAD_SUPPORT
+linux-g++:DEFINES       *= LINUX
+cygwin-g++:DEFINES      *= CYGWIN
+irix-n32:DEFINES        *= IRIX
+mac:DEFINES             *= MACOSX
+
+#
+# BUILD DIRECTORIES (RELATIVE)
+#
+#######################################
+
+release {
+  win32 {
+    REL_OBJECTS_DIR   = \\win32\\release\\obj
+    REL_DESTDIR       = \\win32\\release
+  }
+  linux-g++ {
+    REL_OBJECTS_DIR   = linux-g++/release/obj
+    REL_DESTDIR       = linux-g++/release
+  }
+  cygwin-g++ {
+    REL_OBJECTS_DIR   = cygwin-g++/release/obj
+    REL_DESTDIR       = cygwin-g++/release
+  }
+  irix-n32 {
+    REL_OBJECTS_DIR   = irix-n32/release/obj
+    REL_DESTDIR       = irix-n32/release
+  }
+  mac {
+    REL_OBJECTS_DIR   = macosx/release/obj
+    REL_DESTDIR       = macosx/release
+  }
+}
+debug {
+  win32 {
+    REL_OBJECTS_DIR   = \\win32\\debug\\obj
+    REL_DESTDIR       = \\win32\\debug
+  }
+  linux-g++ {
+    REL_OBJECTS_DIR   = linux-g++/debug/obj
+    REL_DESTDIR       = linux-g++/debug
+  }
+  cygwin-g++ {
+    REL_OBJECTS_DIR   = cygwin-g++/debug/obj
+    REL_DESTDIR       = cygwin-g++/debug
+  }
+  irix-n32 {
+    REL_OBJECTS_DIR   = irix-n32/debug/obj
+    REL_DESTDIR       = irix-n32/debug
+  }
+  mac {
+    REL_OBJECTS_DIR   = macosx/debug/obj
+    REL_DESTDIR       = macosx/debug
+  }
+}
+
+#
+# INSTALL
+#
+#######################################
+
+#QMAKE_COPY_FILE       = $${QMAKE_COPY} -P
diff --git a/source/blender/freestyle/misc/Freestyle-vc7-debug.sln b/source/blender/freestyle/misc/Freestyle-vc7-debug.sln
new file mode 100755
index 00000000000..937f3f9faf9
--- /dev/null
+++ b/source/blender/freestyle/misc/Freestyle-vc7-debug.sln
@@ -0,0 +1,113 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Freestyle_d", "app\app_d.vcproj", "{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}"
+	ProjectSection(ProjectDependencies) = postProject
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361} = {DFCED64E-AEFA-4D06-8609-DE23A69D0361}
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30} = {AF37DD50-8CD3-4339-AB32-C6F8F770CB30}
+		{FA76B552-8A89-4A50-92F7-A77935515005} = {FA76B552-8A89-4A50-92F7-A77935515005}
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C} = {9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD} = {4C44396A-8016-4360-8F5C-35CA6CC282BD}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleGeometry_d", "geometry\geometry_d.vcproj", "{3E1C0A57-8206-402F-A12E-3B100F121DDE}"
+	ProjectSection(ProjectDependencies) = postProject
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleImage_d", "image\image_d.vcproj", "{4C44396A-8016-4360-8F5C-35CA6CC282BD}"
+	ProjectSection(ProjectDependencies) = postProject
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleRendering_d", "rendering\rendering_d.vcproj", "{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}"
+	ProjectSection(ProjectDependencies) = postProject
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361} = {DFCED64E-AEFA-4D06-8609-DE23A69D0361}
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSceneGraph_d", "scene_graph\scene_graph_d.vcproj", "{858093EF-6B95-4D0F-AA0A-CF187C6F369F}"
+	ProjectSection(ProjectDependencies) = postProject
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleStroke_d", "stroke\stroke_d.vcproj", "{DFCED64E-AEFA-4D06-8609-DE23A69D0361}"
+	ProjectSection(ProjectDependencies) = postProject
+		{FA76B552-8A89-4A50-92F7-A77935515005} = {FA76B552-8A89-4A50-92F7-A77935515005}
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSystem_d", "system\system_d.vcproj", "{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleViewMap_d", "view_map\view_map_d.vcproj", "{FA76B552-8A89-4A50-92F7-A77935515005}"
+	ProjectSection(ProjectDependencies) = postProject
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30} = {AF37DD50-8CD3-4339-AB32-C6F8F770CB30}
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD} = {4C44396A-8016-4360-8F5C-35CA6CC282BD}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleWingedEdge_d", "winged_edge\winged_edge_d.vcproj", "{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}"
+	ProjectSection(ProjectDependencies) = postProject
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Debug.ActiveCfg = Debug|Win32
+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Debug.Build.0 = Debug|Win32
+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Release.ActiveCfg = Debug|Win32
+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Release.Build.0 = Debug|Win32
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Debug.ActiveCfg = Debug|Win32
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Debug.Build.0 = Debug|Win32
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Release.ActiveCfg = Debug|Win32
+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Release.Build.0 = Debug|Win32
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Debug.ActiveCfg = Debug|Win32
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Debug.Build.0 = Debug|Win32
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Release.ActiveCfg = Debug|Win32
+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Release.Build.0 = Debug|Win32
+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Debug.ActiveCfg = Debug|Win32
+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Debug.Build.0 = Debug|Win32
+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Release.ActiveCfg = Debug|Win32
+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Release.Build.0 = Debug|Win32
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Debug.ActiveCfg = Debug|Win32
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Debug.Build.0 = Debug|Win32
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Release.ActiveCfg = Debug|Win32
+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Release.Build.0 = Debug|Win32
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Debug.ActiveCfg = Debug|Win32
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Debug.Build.0 = Debug|Win32
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Release.ActiveCfg = Debug|Win32
+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Release.Build.0 = Debug|Win32
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Debug.ActiveCfg = Debug|Win32
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Debug.Build.0 = Debug|Win32
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Release.ActiveCfg = Debug|Win32
+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Release.Build.0 = Debug|Win32
+		{FA76B552-8A89-4A50-92F7-A77935515005}.Debug.ActiveCfg = Debug|Win32
+		{FA76B552-8A89-4A50-92F7-A77935515005}.Debug.Build.0 = Debug|Win32
+		{FA76B552-8A89-4A50-92F7-A77935515005}.Release.ActiveCfg = Release|Win32
+		{FA76B552-8A89-4A50-92F7-A77935515005}.Release.Build.0 = Release|Win32
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Debug.ActiveCfg = Debug|Win32
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Debug.Build.0 = Debug|Win32
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Release.ActiveCfg = Debug|Win32
+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Release.Build.0 = Debug|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/source/blender/freestyle/misc/Freestyle-vc7-release.sln b/source/blender/freestyle/misc/Freestyle-vc7-release.sln
new file mode 100755
index 00000000000..74d5dc77f86
--- /dev/null
+++ b/source/blender/freestyle/misc/Freestyle-vc7-release.sln
@@ -0,0 +1,111 @@
+Microsoft Visual Studio Solution File, Format Version 8.00

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Freestyle", "app\app.vcproj", "{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}"

+	ProjectSection(ProjectDependencies) = postProject

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361} = {DFCED64E-AEFA-4D06-8609-DE23A69D0361}

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30} = {AF37DD50-8CD3-4339-AB32-C6F8F770CB30}

+		{FA76B552-8A89-4A50-92F7-A77935515005} = {FA76B552-8A89-4A50-92F7-A77935515005}

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C} = {9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD} = {4C44396A-8016-4360-8F5C-35CA6CC282BD}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleGeometry", "geometry\geometry.vcproj", "{3E1C0A57-8206-402F-A12E-3B100F121DDE}"

+	ProjectSection(ProjectDependencies) = postProject

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleImage", "image\image.vcproj", "{4C44396A-8016-4360-8F5C-35CA6CC282BD}"

+	ProjectSection(ProjectDependencies) = postProject

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleRendering", "rendering\rendering.vcproj", "{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}"

+	ProjectSection(ProjectDependencies) = postProject

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361} = {DFCED64E-AEFA-4D06-8609-DE23A69D0361}

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSceneGraph", "scene_graph\scene_graph.vcproj", "{858093EF-6B95-4D0F-AA0A-CF187C6F369F}"

+	ProjectSection(ProjectDependencies) = postProject

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleStroke", "stroke\stroke.vcproj", "{DFCED64E-AEFA-4D06-8609-DE23A69D0361}"

+	ProjectSection(ProjectDependencies) = postProject

+		{FA76B552-8A89-4A50-92F7-A77935515005} = {FA76B552-8A89-4A50-92F7-A77935515005}

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSystem", "system\system.vcproj", "{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}"

+	ProjectSection(ProjectDependencies) = postProject

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleViewMap", "view_map\view_map.vcproj", "{FA76B552-8A89-4A50-92F7-A77935515005}"

+	ProjectSection(ProjectDependencies) = postProject

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30} = {AF37DD50-8CD3-4339-AB32-C6F8F770CB30}

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD} = {4C44396A-8016-4360-8F5C-35CA6CC282BD}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleWingedEdge", "winged_edge\winged_edge.vcproj", "{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}"

+	ProjectSection(ProjectDependencies) = postProject

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE} = {3E1C0A57-8206-402F-A12E-3B100F121DDE}

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A} = {AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F} = {858093EF-6B95-4D0F-AA0A-CF187C6F369F}

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfiguration) = preSolution

+		Debug = Debug

+		Release = Release

+	EndGlobalSection

+	GlobalSection(ProjectConfiguration) = postSolution

+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Debug.ActiveCfg = Debug|Win32

+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Debug.Build.0 = Debug|Win32

+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Release.ActiveCfg = Release|Win32

+		{0BC94A80-9E3E-40D8-B2CF-6594F96361C5}.Release.Build.0 = Release|Win32

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Debug.ActiveCfg = Debug|Win32

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Debug.Build.0 = Debug|Win32

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Release.ActiveCfg = Release|Win32

+		{3E1C0A57-8206-402F-A12E-3B100F121DDE}.Release.Build.0 = Release|Win32

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Debug.ActiveCfg = Debug|Win32

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Debug.Build.0 = Debug|Win32

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Release.ActiveCfg = Release|Win32

+		{4C44396A-8016-4360-8F5C-35CA6CC282BD}.Release.Build.0 = Release|Win32

+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Debug.ActiveCfg = Debug|Win32

+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Debug.Build.0 = Debug|Win32

+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Release.ActiveCfg = Release|Win32

+		{9F2B9C57-F57F-4A8A-9590-6DDD1E51433C}.Release.Build.0 = Release|Win32

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Debug.ActiveCfg = Debug|Win32

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Debug.Build.0 = Debug|Win32

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Release.ActiveCfg = Release|Win32

+		{858093EF-6B95-4D0F-AA0A-CF187C6F369F}.Release.Build.0 = Release|Win32

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Debug.ActiveCfg = Debug|Win32

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Debug.Build.0 = Debug|Win32

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Release.ActiveCfg = Release|Win32

+		{DFCED64E-AEFA-4D06-8609-DE23A69D0361}.Release.Build.0 = Release|Win32

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Debug.ActiveCfg = Debug|Win32

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Debug.Build.0 = Debug|Win32

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Release.ActiveCfg = Release|Win32

+		{AE79BAD6-6F46-4AA1-BBEA-28CC209FC28A}.Release.Build.0 = Release|Win32

+		{FA76B552-8A89-4A50-92F7-A77935515005}.Debug.ActiveCfg = Debug|Win32

+		{FA76B552-8A89-4A50-92F7-A77935515005}.Debug.Build.0 = Debug|Win32

+		{FA76B552-8A89-4A50-92F7-A77935515005}.Release.ActiveCfg = Release|Win32

+		{FA76B552-8A89-4A50-92F7-A77935515005}.Release.Build.0 = Release|Win32

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Debug.ActiveCfg = Debug|Win32

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Debug.Build.0 = Debug|Win32

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Release.ActiveCfg = Release|Win32

+		{AF37DD50-8CD3-4339-AB32-C6F8F770CB30}.Release.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ExtensibilityGlobals) = postSolution

+	EndGlobalSection

+	GlobalSection(ExtensibilityAddIns) = postSolution

+	EndGlobalSection

+EndGlobal

diff --git a/source/blender/freestyle/misc/Freestyle-vc8-debug.sln b/source/blender/freestyle/misc/Freestyle-vc8-debug.sln
new file mode 100755
index 00000000000..097ca30a174
--- /dev/null
+++ b/source/blender/freestyle/misc/Freestyle-vc8-debug.sln
@@ -0,0 +1,87 @@
+

+Microsoft Visual Studio Solution File, Format Version 9.00

+# Visual C++ Express 2005

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSystem_d", "system\system_d.vcproj", "{AAAAA9BB-8C01-3BC3-9808-AB6717F08393}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleGeometry_d", "geometry\geometry_d.vcproj", "{5F60164C-8544-3259-A8CB-24636A092489}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleImage_d", "image\image_d.vcproj", "{28F6AC11-2A9B-3886-97DD-82FB353409CB}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSceneGraph_d", "scene_graph\scene_graph_d.vcproj", "{C98C60D8-9836-30A5-BEA9-0D320E5AF308}"

+	ProjectSection(ProjectDependencies) = postProject

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleWingedEdge_d", "winged_edge\winged_edge_d.vcproj", "{E46825D6-9581-3D8A-96FE-7C90BC188602}"

+	ProjectSection(ProjectDependencies) = postProject

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308} = {C98C60D8-9836-30A5-BEA9-0D320E5AF308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleViewMap_d", "view_map\view_map_d.vcproj", "{6769BAB7-2894-3453-B07A-58C32D6646E3}"

+	ProjectSection(ProjectDependencies) = postProject

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308} = {C98C60D8-9836-30A5-BEA9-0D320E5AF308}

+		{E46825D6-9581-3D8A-96FE-7C90BC188602} = {E46825D6-9581-3D8A-96FE-7C90BC188602}

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleStroke_d", "stroke\stroke_d.vcproj", "{EDA5F096-B8D0-336F-82DB-501B2F00C1CD}"

+	ProjectSection(ProjectDependencies) = postProject

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+		{6769BAB7-2894-3453-B07A-58C32D6646E3} = {6769BAB7-2894-3453-B07A-58C32D6646E3}

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{E46825D6-9581-3D8A-96FE-7C90BC188602} = {E46825D6-9581-3D8A-96FE-7C90BC188602}

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308} = {C98C60D8-9836-30A5-BEA9-0D320E5AF308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleRendering_d", "rendering\rendering_d.vcproj", "{D5EA771F-A1FF-3F68-A391-98EEEB407E78}"

+	ProjectSection(ProjectDependencies) = postProject

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+		{EDA5F096-B8D0-336F-82DB-501B2F00C1CD} = {EDA5F096-B8D0-336F-82DB-501B2F00C1CD}

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308} = {C98C60D8-9836-30A5-BEA9-0D320E5AF308}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Freestyle_d", "app\app_d.vcproj", "{606D6459-D5F6-3A09-8962-50E8551545AB}"

+	ProjectSection(ProjectDependencies) = postProject

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308} = {C98C60D8-9836-30A5-BEA9-0D320E5AF308}

+		{E46825D6-9581-3D8A-96FE-7C90BC188602} = {E46825D6-9581-3D8A-96FE-7C90BC188602}

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393} = {AAAAA9BB-8C01-3BC3-9808-AB6717F08393}

+		{6769BAB7-2894-3453-B07A-58C32D6646E3} = {6769BAB7-2894-3453-B07A-58C32D6646E3}

+		{EDA5F096-B8D0-336F-82DB-501B2F00C1CD} = {EDA5F096-B8D0-336F-82DB-501B2F00C1CD}

+		{5F60164C-8544-3259-A8CB-24636A092489} = {5F60164C-8544-3259-A8CB-24636A092489}

+		{D5EA771F-A1FF-3F68-A391-98EEEB407E78} = {D5EA771F-A1FF-3F68-A391-98EEEB407E78}

+		{28F6AC11-2A9B-3886-97DD-82FB353409CB} = {28F6AC11-2A9B-3886-97DD-82FB353409CB}

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|Win32 = Debug|Win32

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393}.Debug|Win32.ActiveCfg = Debug|Win32

+		{AAAAA9BB-8C01-3BC3-9808-AB6717F08393}.Debug|Win32.Build.0 = Debug|Win32

+		{5F60164C-8544-3259-A8CB-24636A092489}.Debug|Win32.ActiveCfg = Debug|Win32

+		{5F60164C-8544-3259-A8CB-24636A092489}.Debug|Win32.Build.0 = Debug|Win32

+		{28F6AC11-2A9B-3886-97DD-82FB353409CB}.Debug|Win32.ActiveCfg = Debug|Win32

+		{28F6AC11-2A9B-3886-97DD-82FB353409CB}.Debug|Win32.Build.0 = Debug|Win32

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308}.Debug|Win32.ActiveCfg = Debug|Win32

+		{C98C60D8-9836-30A5-BEA9-0D320E5AF308}.Debug|Win32.Build.0 = Debug|Win32

+		{E46825D6-9581-3D8A-96FE-7C90BC188602}.Debug|Win32.ActiveCfg = Debug|Win32

+		{E46825D6-9581-3D8A-96FE-7C90BC188602}.Debug|Win32.Build.0 = Debug|Win32

+		{6769BAB7-2894-3453-B07A-58C32D6646E3}.Debug|Win32.ActiveCfg = Debug|Win32

+		{6769BAB7-2894-3453-B07A-58C32D6646E3}.Debug|Win32.Build.0 = Debug|Win32

+		{EDA5F096-B8D0-336F-82DB-501B2F00C1CD}.Debug|Win32.ActiveCfg = Debug|Win32

+		{EDA5F096-B8D0-336F-82DB-501B2F00C1CD}.Debug|Win32.Build.0 = Debug|Win32

+		{D5EA771F-A1FF-3F68-A391-98EEEB407E78}.Debug|Win32.ActiveCfg = Debug|Win32

+		{D5EA771F-A1FF-3F68-A391-98EEEB407E78}.Debug|Win32.Build.0 = Debug|Win32

+		{606D6459-D5F6-3A09-8962-50E8551545AB}.Debug|Win32.ActiveCfg = Debug|Win32

+		{606D6459-D5F6-3A09-8962-50E8551545AB}.Debug|Win32.Build.0 = Debug|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/source/blender/freestyle/misc/Freestyle-vc8-release.sln b/source/blender/freestyle/misc/Freestyle-vc8-release.sln
new file mode 100755
index 00000000000..82b22ff0c3e
--- /dev/null
+++ b/source/blender/freestyle/misc/Freestyle-vc8-release.sln
@@ -0,0 +1,87 @@
+

+Microsoft Visual Studio Solution File, Format Version 9.00

+# Visual C++ Express 2005

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Freestyle", "app\app.vcproj", "{B56F2464-158F-32C1-A9F7-EE85397706EC}"

+	ProjectSection(ProjectDependencies) = postProject

+		{555B73B2-B07B-3865-9D41-0FB69091E0C9} = {555B73B2-B07B-3865-9D41-0FB69091E0C9}

+		{F6589FA0-9FA2-31F9-BD0F-FFE303DE8759} = {F6589FA0-9FA2-31F9-BD0F-FFE303DE8759}

+		{9A93A87D-09E4-3492-A68C-A7B1A38DE002} = {9A93A87D-09E4-3492-A68C-A7B1A38DE002}

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+		{A494B81F-F5EC-35DE-8DDC-4F6FD6B536D5} = {A494B81F-F5EC-35DE-8DDC-4F6FD6B536D5}

+		{35891119-E049-35BB-AB8E-8536817F5CEE} = {35891119-E049-35BB-AB8E-8536817F5CEE}

+		{0FDD8610-0785-3089-900D-53F786E9AC9B} = {0FDD8610-0785-3089-900D-53F786E9AC9B}

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleGeometry", "geometry\geometry.vcproj", "{1D57A40D-AE4B-3E40-A023-4F37C9D7446C}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleImage", "image\image.vcproj", "{A494B81F-F5EC-35DE-8DDC-4F6FD6B536D5}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleRendering", "rendering\rendering.vcproj", "{0FDD8610-0785-3089-900D-53F786E9AC9B}"

+	ProjectSection(ProjectDependencies) = postProject

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+		{35891119-E049-35BB-AB8E-8536817F5CEE} = {35891119-E049-35BB-AB8E-8536817F5CEE}

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+		{9A93A87D-09E4-3492-A68C-A7B1A38DE002} = {9A93A87D-09E4-3492-A68C-A7B1A38DE002}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSceneGraph", "scene_graph\scene_graph.vcproj", "{35891119-E049-35BB-AB8E-8536817F5CEE}"

+	ProjectSection(ProjectDependencies) = postProject

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleStroke", "stroke\stroke.vcproj", "{9A93A87D-09E4-3492-A68C-A7B1A38DE002}"

+	ProjectSection(ProjectDependencies) = postProject

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+		{35891119-E049-35BB-AB8E-8536817F5CEE} = {35891119-E049-35BB-AB8E-8536817F5CEE}

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+		{F6589FA0-9FA2-31F9-BD0F-FFE303DE8759} = {F6589FA0-9FA2-31F9-BD0F-FFE303DE8759}

+		{555B73B2-B07B-3865-9D41-0FB69091E0C9} = {555B73B2-B07B-3865-9D41-0FB69091E0C9}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleSystem", "system\system.vcproj", "{3804962B-1D5B-382E-B69E-96FFB2372A46}"

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleViewMap", "view_map\view_map.vcproj", "{F6589FA0-9FA2-31F9-BD0F-FFE303DE8759}"

+	ProjectSection(ProjectDependencies) = postProject

+		{555B73B2-B07B-3865-9D41-0FB69091E0C9} = {555B73B2-B07B-3865-9D41-0FB69091E0C9}

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+		{35891119-E049-35BB-AB8E-8536817F5CEE} = {35891119-E049-35BB-AB8E-8536817F5CEE}

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FreestyleWingedEdge", "winged_edge\winged_edge.vcproj", "{555B73B2-B07B-3865-9D41-0FB69091E0C9}"

+	ProjectSection(ProjectDependencies) = postProject

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C} = {1D57A40D-AE4B-3E40-A023-4F37C9D7446C}

+		{35891119-E049-35BB-AB8E-8536817F5CEE} = {35891119-E049-35BB-AB8E-8536817F5CEE}

+		{3804962B-1D5B-382E-B69E-96FFB2372A46} = {3804962B-1D5B-382E-B69E-96FFB2372A46}

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Release|Win32 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{B56F2464-158F-32C1-A9F7-EE85397706EC}.Release|Win32.ActiveCfg = Release|Win32

+		{B56F2464-158F-32C1-A9F7-EE85397706EC}.Release|Win32.Build.0 = Release|Win32

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C}.Release|Win32.ActiveCfg = Release|Win32

+		{1D57A40D-AE4B-3E40-A023-4F37C9D7446C}.Release|Win32.Build.0 = Release|Win32

+		{A494B81F-F5EC-35DE-8DDC-4F6FD6B536D5}.Release|Win32.ActiveCfg = Release|Win32

+		{A494B81F-F5EC-35DE-8DDC-4F6FD6B536D5}.Release|Win32.Build.0 = Release|Win32

+		{0FDD8610-0785-3089-900D-53F786E9AC9B}.Release|Win32.ActiveCfg = Release|Win32

+		{0FDD8610-0785-3089-900D-53F786E9AC9B}.Release|Win32.Build.0 = Release|Win32

+		{35891119-E049-35BB-AB8E-8536817F5CEE}.Release|Win32.ActiveCfg = Release|Win32

+		{35891119-E049-35BB-AB8E-8536817F5CEE}.Release|Win32.Build.0 = Release|Win32

+		{9A93A87D-09E4-3492-A68C-A7B1A38DE002}.Release|Win32.ActiveCfg = Release|Win32

+		{9A93A87D-09E4-3492-A68C-A7B1A38DE002}.Release|Win32.Build.0 = Release|Win32

+		{3804962B-1D5B-382E-B69E-96FFB2372A46}.Release|Win32.ActiveCfg = Release|Win32

+		{3804962B-1D5B-382E-B69E-96FFB2372A46}.Release|Win32.Build.0 = Release|Win32

+		{F6589FA0-9FA2-31F9-BD0F-FFE303DE8759}.Release|Win32.ActiveCfg = Release|Win32

+		{F6589FA0-9FA2-31F9-BD0F-FFE303DE8759}.Release|Win32.Build.0 = Release|Win32

+		{555B73B2-B07B-3865-9D41-0FB69091E0C9}.Release|Win32.ActiveCfg = Release|Win32

+		{555B73B2-B07B-3865-9D41-0FB69091E0C9}.Release|Win32.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/source/blender/freestyle/misc/INSTALL.TXT b/source/blender/freestyle/misc/INSTALL.TXT
new file mode 100755
index 00000000000..4fab1275116
--- /dev/null
+++ b/source/blender/freestyle/misc/INSTALL.TXT
@@ -0,0 +1,79 @@
+Install
+-------
+
+* UNIX/LINUX
+
+(for a more detailed description, see doc/linuxinstall.html)
+
+  This is quite straightforward, provided that you have all the
+needed libraries properly installed (see Requirements section in
+the README.TXT file). 
+First, set the FREESTYLE-DIR environment variable to your 
+freestyle directory and then, simply type:
+
+$> cd "$FREESTYLE_DIR"/src
+$> qmake
+$> make
+
+Note: The SWIG wrapper hasn't been included in the qmake build
+cycle yet and thus has to be compiled separately, by hand:
+
+$> cd "$FREESTYLE_DIR"/src/swig
+$> make
+
+And to run the app:
+
+$> export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:./lib"
+$> cd "$FREESTYLE_DIR"/build/linux-g++/release/
+$> ./Freestyle
+
+
+* WINDOWS
+
+ - If you downloaded the binary version:
+
+1) unzip the package
+2) run vcredist_x86.exe
+3) run Freestyle.exe
+
+- Compilation Instructions:
+
+(for a more detailed description, including the cygwin
+compilation instructions, see doc/wininstall.html)
+
+1) launch 'makedsp.vcnet.debug.bat' in the 'src' subdir of your FREESTYLE_DIR to generate
+  a .vcproj file for each sub-project
+2) open 'src/Freestyle-vc8-debug.sln' with Visual Studio (tested with VC++ 8 express edition)
+3) compile the whole project using 'build solution' in the 'build' menu 
+4) run the app and enjoy ;)
+
+* MAC OS X
+
+(for a more detailed description, see doc/macosxinstall.html)
+
+  This is quite straightforward, provided that you have all the
+needed libraries properly installed (see Requirements section in
+the README.TXT file). 
+First, set the FREESTYLE-DIR environment variable to your 
+freestyle directory and then, simply type:
+
+$> cd "$FREESTYLE_DIR"/src
+$> qmake
+$> make
+
+Note: The SWIG wrapper hasn't been included in the qmake build
+cycle yet and thus has to be compiled separately, by hand:
+
+$> cd "$FREESTYLE_DIR"/src/swig
+$> make
+
+And to run the app:
+
+$> build_bundle.macosx.py
+$> cd "$FREESTYLE_DIR"/
+$> open Freestyle.App
+
+
+* IRIX
+
+Not tested yet...
diff --git a/source/blender/freestyle/misc/LICENSE.TXT b/source/blender/freestyle/misc/LICENSE.TXT
new file mode 100755
index 00000000000..5b6e7c66c27
--- /dev/null
+++ b/source/blender/freestyle/misc/LICENSE.TXT
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/source/blender/freestyle/misc/Makefile.pro b/source/blender/freestyle/misc/Makefile.pro
new file mode 100755
index 00000000000..0e64bb342c3
--- /dev/null
+++ b/source/blender/freestyle/misc/Makefile.pro
@@ -0,0 +1,18 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+#			      W A R N I N G ! ! !                             #
+#             a u t h o r i z e d    p e r s o n a l    o n l y               #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+TEMPLATE = subdirs
+SUBDIRS  = system \
+           image \
+           geometry \
+           scene_graph \
+           winged_edge \
+           view_map \
+           stroke \
+           rendering \
+#          swig \
+           app
+
+
diff --git a/source/blender/freestyle/misc/README.TXT b/source/blender/freestyle/misc/README.TXT
new file mode 100755
index 00000000000..b0d026c8b9b
--- /dev/null
+++ b/source/blender/freestyle/misc/README.TXT
@@ -0,0 +1,51 @@
+Freestyle, a procedural line drawing system
+http://freestyle.sourceforge.net
+
+INTRODUCTION
+------------
+Freestyle is a software for Non-Photorealistic Line Drawing rendering
+from 3D scenes. It is designed as a programmable interface to allow
+maximum control over the style of the final drawing: the user
+"programs" how the silhouettes and other feature lines from the 3D
+model should be turned into stylized strokes using a set of
+programmable operators dedicated to style description. This
+programmable approach, inspired by the shading languages available in
+photorealistic renderers such as Pixar's RenderMan, overcomes the
+limitations of integrated software with access to a limited number of
+parameters and permits the design of an infinite variety of rich and
+complex styles. The system currently focuses on pure line drawing as a
+first step. The style description language is Python augmented with
+our set of operators.  Freestyle was developed in the framework of a
+research project dedicated to the study of stylized line drawing
+rendering from 3D scenes. Details about this research can be found at:
+
+http://artis.imag.fr/Projects/Style
+
+This software is distributed under
+the terms of the GPL License.
+
+INSTALL
+-------
+Please see the file INSTALL.TXT for instructions on installation.
+
+REQUIREMENTS
+------------
+- OpenGL        >= 1.2
+- libQGLViewer  = 2.2.5-1
+- lib3ds        = 1.2
+- Qt            = 4.2.3
+- SWIG          = 1.3.31
+- Python        = 2.5
+
+For Linux and MacOSX:
+- g++           = 4.0 or 4.1
+
+For Windows:
+- Visual Studio = 2003 or 2005
+
+CONTACTING THE AUTHORS
+----------------------
+See the AUTHORS.TXT file for contact information.
+
+Thank you for your interest in this project, we hope you enjoy using it.
+---
diff --git a/source/blender/freestyle/misc/THANKS.TXT b/source/blender/freestyle/misc/THANKS.TXT
new file mode 100755
index 00000000000..3147715a63f
--- /dev/null
+++ b/source/blender/freestyle/misc/THANKS.TXT
@@ -0,0 +1,6 @@
+The following is an incomplete list of people that have contributed to this 
+project in some way or another, in no particular order...
+
+* Thomas Netter (lib3ds fix)
+* Gilles Debunne, creator and maintainer of the great libQGLViewer.
+* Mark Rose, for his work on the SWIG director feature, and his help.
diff --git a/source/blender/freestyle/misc/TODO.TXT b/source/blender/freestyle/misc/TODO.TXT
new file mode 100755
index 00000000000..2e24752e026
--- /dev/null
+++ b/source/blender/freestyle/misc/TODO.TXT
@@ -0,0 +1,9 @@
+sgrabli:
+--------
+
+* Update help and make it display correctly
+* Recode the ViewMap building - the Y junctions are not detected for smooth objects right now.
+* Check the strokes strippification code. It seems some parts are inverted.
+* Fix the pbuffer so that ATI cards are supported
+
+* Merge Chain and Stroke classes (to Stroke) and improve the base of operators (select, chain, split, shade) consquently (also think about a way to easily specify the pipeline synchronization mode).
diff --git a/source/blender/freestyle/misc/build_bundle.macosx.py b/source/blender/freestyle/misc/build_bundle.macosx.py
new file mode 100755
index 00000000000..e97153f269c
--- /dev/null
+++ b/source/blender/freestyle/misc/build_bundle.macosx.py
@@ -0,0 +1,183 @@
+#!/usr/bin/python
+
+import os,sys,string
+
+install_dependencies=["GLUT",\
+                          "QtCore", "QtGui", "QtXml", \
+                          "libQGLViewer", "FreestyleSystem", "FreestyleRendering",\
+                        "FreestyleImage","FreestyleGeometry", "FreestyleSceneGraph", "FreestyleWingedEdge",\
+                        "FreestyleViewMap", "FreestyleStroke"]
+
+if not("FREESTYLE_DIR" in os.environ):
+    print "FREESTYLE_DIR must be set to your Freestyle directory"
+    sys.exit()
+    
+src_dir_path=os.environ['FREESTYLE_DIR']
+dest_dir_path=os.path.join(os.environ['FREESTYLE_DIR'], "freestyle.2.0.0-macosx-x86")
+bundle_name="Freestyle.app"
+bundle_path=os.path.join(dest_dir_path,bundle_name)
+frameworks_path=os.path.join(bundle_path,"Contents/Frameworks")
+exe_path=os.path.join(bundle_path, "Contents/MacOS")
+original_lib_path=os.path.join(src_dir_path,"build/macosx/release/lib")
+original_exe_path=os.path.join(src_dir_path,"build/macosx/release",bundle_name,"Contents/MacOS")
+                               
+
+
+# Builds a dictionary of dependencies for
+# a given binary
+# The table format is:
+# "dependency name" "dependency path"
+def buildDependenciesTable(binary_file, dep_table):
+    cmd="otool -L %s" % binary_file
+    #print cmd
+    #otool_output = os.system(cmd)
+    otool_output = os.popen(cmd).read().split('\n')
+    for dep_text in otool_output:
+        if (dep_text.count(":") == 0):
+            dep = dep_text.split(' ')[0].lstrip()
+            dep_base_name=os.path.basename(dep)
+            dep_table[dep_base_name] = dep
+    
+
+def fixPaths(dep_table):
+    for k,v in dep_table.items():
+        if(k.count("Freestyle")):
+            dep_table[k] = os.path.join(src_dir_path, "build/macosx/release/lib",v)
+        if(k.count("QGLViewer")):
+            dep_table[k] = os.path.join("/usr/lib", v)
+
+def extractFrameworkBaseDir(framework_lib):
+    parts=framework_lib.split("/")
+    head="/"
+    tail=""
+    in_head=True
+    for p in parts:
+        if(in_head == True):
+            head=os.path.join(head,p)
+        else:
+            tail=os.path.join(tail,p)
+        if(p.count(".framework") != 0):
+            in_head=False
+    return (head,tail)    
+    
+def installDependencies(dep_table, install_dependencies, new_dep_table):
+    for k,v in dep_table.items():
+        for d in install_dependencies:
+            if(k.count(d)!=0):
+                framework_dir_path=v
+                cp_option=""
+                head=""
+                tail=""
+                if(v.count("framework")):
+                    (head,tail) = extractFrameworkBaseDir(v)
+                    framework_dir_path=head
+                    cp_option="-R"
+                lib_name=os.path.split(framework_dir_path)[1]
+                target=os.path.join(frameworks_path,lib_name)
+                # update new table
+                if(tail != ""):
+                    new_dep_table[k] = os.path.join("@executable_path/../Frameworks",lib_name,tail)
+                else:
+                    new_dep_table[k] = os.path.join("@executable_path/../Frameworks",lib_name)
+                if(os.path.exists(target) != True):    
+                    cmd = "cp %s %s %s" % (cp_option, framework_dir_path,frameworks_path)
+                    print "Installing dependency:",lib_name
+                    os.system(cmd)
+
+def updatePathsToDependencies(binary_file, install_dependencies, dep_table, new_dep_table):
+    # executable:
+    f_dep_table={}
+    buildDependenciesTable(binary_file,f_dep_table)
+    for k,v in f_dep_table.items():
+        # is k in install_dependencies?
+        for ld in install_dependencies:
+            if(k.count(ld) != 0):
+                #print new_dep_table
+                cmd="install_name_tool -change %s %s %s" % (v,new_dep_table[k], binary_file)
+                os.system(cmd)
+    # check
+    cmd="otool -L %s" % binary_file
+    os.system(cmd)
+
+def cleanDir(dir, to_delete):
+    os.chdir(dir)
+    #print os.getcwd()
+    for d in os.listdir("."):
+        #print d
+        if(d == "Headers"):
+            cmd="rm -rf Headers"
+            to_delete.append(os.path.join(dir,d))
+            #os.system(cmd)
+        elif(d.count("debug") != 0):
+            cmd="rm -rf %s"%(d)
+            #print cmd
+            to_delete.append(os.path.join(dir,d))
+            #os.system(cmd)
+        elif(os.path.isdir(d) == True):
+            #print d
+            cleanDir(os.path.join(dir,d), to_delete)
+        #else:
+        #    print d
+    os.chdir(os.path.join(dir,".."))
+    #print os.getcwd()
+
+    
+# build bundle structure
+if( os.path.exists(dest_dir_path) != True):
+    print "Creating directory",dest_dir_path
+    os.mkdir(dest_dir_path)
+
+if(os.path.exists(bundle_path) != True):
+    print "Creating the bundle structure", bundle_path
+    cmd = "cp -R %s %s" % (os.path.join(src_dir_path, "build/macosx/release/",bundle_name), bundle_path)
+    os.system(cmd)
+    os.mkdir(os.path.join(bundle_path,"Contents/Frameworks"))
+  
+                
+dep_table = {}
+new_dep_table = {}
+# Executable
+for f in os.listdir(original_exe_path):
+    if(f[0] == '.'):
+        continue
+    exe_file_path=os.path.join(original_exe_path, f)
+    buildDependenciesTable(exe_file_path, dep_table)
+    
+# Frameworks    
+for f in os.listdir(original_lib_path):
+    if (f.count("framework") == 0):
+        continue
+    f_name=f.split('.')[0]
+    fwk_path=os.path.join(original_lib_path, "%s.framework" % f_name,f_name)
+    buildDependenciesTable(fwk_path, dep_table)
+                               
+# Fix ad-hoc paths
+fixPaths(dep_table)
+    
+# install dependent libs
+installDependencies(dep_table, install_dependencies, new_dep_table)
+
+# update paths to installed dependencies
+for f in os.listdir(exe_path):
+    if(f[0] == '.'):
+        continue
+    updatePathsToDependencies(os.path.join(exe_path,f), install_dependencies, dep_table, new_dep_table)
+    
+# Frameworks    
+for f in os.listdir(frameworks_path):
+    if (f.count("framework") == 0):
+        continue
+    f_name=f.split('.')[0]
+    fwk_path=os.path.join(frameworks_path, "%s.framework" % f_name,f_name)
+    updatePathsToDependencies(fwk_path, install_dependencies, dep_table, new_dep_table)
+    
+
+# Clean-up
+# Remove debug libs
+print "Cleaning..."
+to_delete=[]
+cleanDir(bundle_path, to_delete)
+for f in to_delete:
+    cmd = "rm -rf %s"%f
+    print cmd
+    os.system(cmd)
diff --git a/source/blender/freestyle/misc/libconfig.pri b/source/blender/freestyle/misc/libconfig.pri
new file mode 100755
index 00000000000..6fec8878694
--- /dev/null
+++ b/source/blender/freestyle/misc/libconfig.pri
@@ -0,0 +1,110 @@
+# This file should be viewed as a -*- mode: Makefile -*-
+
+contains( CONFIG, 3ds1.20 ) {
+  message ("Using 3ds 1.2.0 module")
+  linux-g++:INCLUDEPATH  *= $(HOME)/INCLUDE/LINUX
+  linux-g++:LIBS         *= -L$(HOME)/LIB/LINUX -l3ds
+  cygwin-g++:INCLUDEPATH  *= /usr/lib/lib3ds-1.2.0
+  cygwin-g++:LIBS         *= -L/usr/lib/lib3ds-1.2.0/lib3ds -l3ds
+  mac:INCLUDEPATH *= /usr/local/include
+  mac:LIBS         *= -l3ds
+  mac:QMAKE_LIBDIR *= /usr/local/lib
+  win32:    INCLUDEPATH  *= C:\include\lib3ds\1.2.0
+  win32:    QMAKE_LIBDIR *= C:\lib\lib3ds\1.2.0
+  win32:debug:    LIBS         *= lib3ds-120sd.lib
+  win32:release:    LIBS         *= lib3ds-120s.lib
+}
+
+contains( CONFIG, 3ds1.30 ) {
+  message ("Using 3ds 1.3.0 module")
+  linux-g++:INCLUDEPATH  *= $(HOME)/INCLUDE/LINUX
+  linux-g++:LIBS         *= -L$(HOME)/LIB/LINUX -l3ds
+  cygwin-g++:INCLUDEPATH  *= /usr/lib/lib3ds-1.3.0
+  cygwin-g++:LIBS         *= -L/usr/lib/lib3ds-1.3.0/lib3ds -l3ds
+  mac:INCLUDEPATH *= /usr/local/include
+  mac:LIBS         *= -l3ds
+  mac:QMAKE_LIBDIR *= /usr/local/lib
+  win32:    INCLUDEPATH  *= C:\include\lib3ds\1.3.0
+  win32:    QMAKE_LIBDIR *= C:\lib\lib3ds\1.3.0
+  win32:debug:    LIBS         *= lib3ds-1_3d.lib
+  win32:release:    LIBS         *= lib3ds-1_3.lib
+}
+
+contains( CONFIG, qglviewer ) {
+  message ("Using QGLViewer module")
+  CONFIG *= qt thread opengl glut
+  linux-g++:INCLUDEPATH *= $(HOME)/INCLUDE
+  linux-g++:LIBS        *= -L$(HOME)/LIB/LINUX -lQGLViewer
+  cygwin-g++:LIBS        *= -lQGLViewer
+  win32:    INCLUDEPATH  *= $(HOME)\INCLUDE
+  win32:    QMAKE_LIBDIR *= $(HOME)\LIB
+  win32:    LIBS        *= QGLViewer.lib
+}
+
+contains( CONFIG, python2.3) {
+  message ("Using python 2.3 module")
+  linux-g++:INCLUDEPATH *= /usr/include/python2.3
+  linux-g++:LIBS	*= -lpthread -lm -lutil	
+  linux-g++:LIBS        *= -L/usr/local/lib/ -lpython2.3 -L$(HOME)/LIB/LINUX 
+  win32:    INCLUDEPATH *= C:\python23\include
+  win32:    QMAKE_LIBDIR *= C:\python23\libs
+  win32:    LIBS        *= python23.lib
+}
+
+contains( CONFIG, python2.4) {
+  message ("Using python 2.4 module")
+  linux-g++:INCLUDEPATH *= /usr/include/python2.4
+  linux-g++:LIBS	*= -lpthread -lm -lutil	
+  linux-g++:LIBS        *= -L/usr/local/lib/ -lpython2.4 -L$(HOME)/LIB/LINUX
+  cygwin-g++:INCLUDEPATH *= /usr/include/python2.4
+  cygwin-g++:LIBS	*= -lpthread -lm -lutil	
+  cygwin-g++:LIBS        *= -L/usr/lib/python2.4/config -lpython2.4 
+  win32:    INCLUDEPATH *= C:\python24\include
+  win32:    QMAKE_LIBDIR *= C:\python24\libs
+  win32:    LIBS        *= python24.lib
+}
+
+contains( CONFIG, python2.5) {
+  message ("Using python 2.5 module")
+  linux-g++:INCLUDEPATH *= /usr/include/python2.5
+  linux-g++:LIBS	*= -lpthread -lm -lutil	
+  linux-g++:LIBS        *= -L/usr/local/lib/ -lpython2.5 -L$(HOME)/LIB/LINUX
+  mac:	    INCLUDEPATH *= /usr/include/python2.5
+  mac:      LIBS        *= -L/usr/lib/python2.5/config -lpython2.5
+  cygwin-g++:INCLUDEPATH *= /usr/include/python2.5
+  cygwin-g++:LIBS	*= -lpthread -lm -lutil	
+  cygwin-g++:LIBS        *= -L/usr/lib/python2.5/config -lpython2.5 
+  win32:    INCLUDEPATH *= C:\python25\include
+  win32:    QMAKE_LIBDIR *= C:\python25\libs
+  win32:    LIBS        *= python25.lib
+}
+
+
+contains( CONFIG, glut) {
+  message ("Using glut module")
+  linux-g++:LIBS *= -lglut -lXi
+  cygwin-g++:LIBS *= -lglut -lXi
+  mac: LIBS *= -framework Glut
+  win32:INCLUDEPATH *= C:\include
+  win32: QMAKE_LIBDIR *= C:\lib\glut
+  win32: LIBS *= glut32.lib
+}
+
+contains( CONFIG, qglviewer2 ) {
+  message ("Using QGLViewer module")
+  CONFIG *= qt thread opengl glut
+  linux-g++:INCLUDEPATH *= $(HOME)/INCLUDE
+  linux-g++:LIBS        *= -L$(HOME)/LIB/LINUX -lQGLViewer
+  mac: LIBS *= -lQGLViewer
+  cygwin-g++:LIBS        *= -lQGLViewer2
+  win32:    INCLUDEPATH  *= C:\include\QGLViewer\2.2.5
+  win32{
+    release{
+      QMAKE_LIBDIR *= C:\lib\QGLViewer\release
+    }
+    debug{
+      QMAKE_LIBDIR *= C:\lib\QGLViewer\debug
+    }
+  }
+  win32:    LIBS        *= QGLViewer2.lib
+}
diff --git a/source/blender/freestyle/misc/makedsp.vcnet.debug.bat b/source/blender/freestyle/misc/makedsp.vcnet.debug.bat
new file mode 100755
index 00000000000..e19ca52b4f7
--- /dev/null
+++ b/source/blender/freestyle/misc/makedsp.vcnet.debug.bat
@@ -0,0 +1,25 @@
+@echo off
+for /D %%d in (*) do call :FOR2 %%d
+rem cd ..
+goto :EOF
+
+:FOR2
+set componentpath=%1
+set dirname=%~n1
+for %%p in (%componentpath%\*.pro) do if exist %%p call :DSP %%p
+
+goto :EOF
+
+:DSP
+set drive=%~d1
+set filepath=%~p1
+cd %drive%%filepath%
+rem echo %drive%%filepath%
+set filename=%~n1
+echo creating %filename%_d.vcproj from %filename%.pro ...
+if %filename% == app (
+  qmake -t vcapp -win32 -o %filename%_d %filename%.pro 
+) else (
+  qmake -t vclib -win32 -o %filename%_d %filename%.pro
+)
+cd..
diff --git a/source/blender/freestyle/misc/makedsp.vcnet.release.bat b/source/blender/freestyle/misc/makedsp.vcnet.release.bat
new file mode 100755
index 00000000000..3050a2fe4ea
--- /dev/null
+++ b/source/blender/freestyle/misc/makedsp.vcnet.release.bat
@@ -0,0 +1,25 @@
+@echo off
+for /D %%d in (*) do call :FOR2 %%d
+rem cd ..
+goto :EOF
+
+:FOR2
+set componentpath=%1
+set dirname=%~n1
+for %%p in (%componentpath%\*.pro) do if exist %%p call :DSP %%p
+
+goto :EOF
+
+:DSP
+set drive=%~d1
+set filepath=%~p1
+cd %drive%%filepath%
+rem echo %drive%%filepath%
+set filename=%~n1
+echo creating %filename%.vcproj from %filename%.pro ...
+if %filename% == app (
+  qmake -t vcapp -win32 -o %filename% %filename%.pro 
+) else (
+  qmake -t vclib -win32 -o %filename% %filename%.pro
+)
+cd..
diff --git a/source/blender/freestyle/python/3ds_export.py b/source/blender/freestyle/python/3ds_export.py
new file mode 100644
index 00000000000..eb7fd079cfd
--- /dev/null
+++ b/source/blender/freestyle/python/3ds_export.py
@@ -0,0 +1,1010 @@
+#!BPY
+# coding: utf-8
+""" 
+Name: '3D Studio (.3ds)...'
+Blender: 243
+Group: 'Export'
+Tooltip: 'Export to 3DS file format (.3ds).'
+"""
+
+__author__ = ["Campbell Barton", "Bob Holcomb", "Richard Lärkäng", "Damien McGinnes", "Mark Stijnman"]
+__url__ = ("blenderartists.org", "www.blender.org", "www.gametutorials.com", "lib3ds.sourceforge.net/")
+__version__ = "0.90a"
+__bpydoc__ = """\
+
+3ds Exporter
+
+This script Exports a 3ds file.
+
+Exporting is based on 3ds loader from www.gametutorials.com(Thanks DigiBen) and using information
+from the lib3ds project (http://lib3ds.sourceforge.net/) sourcecode.
+"""
+
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# Script copyright (C) Bob Holcomb 
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# ***** END GPL LICENCE BLOCK *****
+# --------------------------------------------------------------------------
+
+
+######################################################
+# Importing modules
+######################################################
+
+import Blender
+import bpy
+from BPyMesh import getMeshFromObject
+from BPyObject import getDerivedObjects
+import struct
+
+# So 3ds max can open files, limit names to 12 in length
+# this is verry annoying for filenames!
+name_unique = []
+name_mapping = {}
+def sane_name(name):
+	name_fixed = name_mapping.get(name)
+	if name_fixed != None:
+		return name_fixed
+	
+	if len(name) > 12:
+		new_name = name[:12]
+	else:
+		new_name = name
+	
+	i = 0
+	
+	while new_name in name_unique:
+		new_name = new_name[:-4] + '.%.3d' % i
+		i+=1
+	
+	name_unique.append(new_name)
+	name_mapping[name] = new_name
+	return new_name
+
+######################################################
+# Data Structures
+######################################################
+
+#Some of the chunks that we will export
+#----- Primary Chunk, at the beginning of each file
+PRIMARY= long("0x4D4D",16)
+
+#------ Main Chunks
+OBJECTINFO   =      long("0x3D3D",16);      #This gives the version of the mesh and is found right before the material and object information
+VERSION      =      long("0x0002",16);      #This gives the version of the .3ds file
+KFDATA       =      long("0xB000",16);      #This is the header for all of the key frame info
+
+#------ sub defines of OBJECTINFO
+MATERIAL=45055		#0xAFFF				// This stored the texture info
+OBJECT=16384		#0x4000				// This stores the faces, vertices, etc...
+
+#>------ sub defines of MATERIAL
+MATNAME    =      long("0xA000",16);      # This holds the material name
+MATAMBIENT   =      long("0xA010",16);      # Ambient color of the object/material
+MATDIFFUSE   =      long("0xA020",16);      # This holds the color of the object/material
+MATSPECULAR   =      long("0xA030",16);      # SPecular color of the object/material
+MATSHINESS   =      long("0xA040",16);      # ??
+MATMAP       =      long("0xA200",16);      # This is a header for a new material
+MATMAPFILE    =      long("0xA300",16);      # This holds the file name of the texture
+
+RGB1=	long("0x0011",16)
+RGB2=	long("0x0012",16)
+
+#>------ sub defines of OBJECT
+OBJECT_MESH  =      long("0x4100",16);      # This lets us know that we are reading a new object
+OBJECT_LIGHT =      long("0x4600",16);      # This lets un know we are reading a light object
+OBJECT_CAMERA=      long("0x4700",16);      # This lets un know we are reading a camera object
+
+#>------ sub defines of CAMERA
+OBJECT_CAM_RANGES=   long("0x4720",16);      # The camera range values
+
+#>------ sub defines of OBJECT_MESH
+OBJECT_VERTICES =   long("0x4110",16);      # The objects vertices
+OBJECT_FACES    =   long("0x4120",16);      # The objects faces
+OBJECT_MATERIAL =   long("0x4130",16);      # This is found if the object has a material, either texture map or color
+OBJECT_UV       =   long("0x4140",16);      # The UV texture coordinates
+OBJECT_TRANS_MATRIX  =   long("0x4160",16); # The Object Matrix
+
+#>------ sub defines of KFDATA
+KFDATA_KFHDR            = long("0xB00A",16);
+KFDATA_KFSEG            = long("0xB008",16);
+KFDATA_KFCURTIME        = long("0xB009",16);
+KFDATA_OBJECT_NODE_TAG  = long("0xB002",16);
+
+#>------ sub defines of OBJECT_NODE_TAG
+OBJECT_NODE_ID          = long("0xB030",16);
+OBJECT_NODE_HDR         = long("0xB010",16);
+OBJECT_PIVOT            = long("0xB013",16);
+OBJECT_INSTANCE_NAME    = long("0xB011",16);
+POS_TRACK_TAG			= long("0xB020",16);
+ROT_TRACK_TAG			= long("0xB021",16);
+SCL_TRACK_TAG			= long("0xB022",16);
+
+def uv_key(uv):
+	return round(uv.x, 6), round(uv.y, 6)
+
+# size defines:	
+SZ_SHORT = 2
+SZ_INT   = 4
+SZ_FLOAT = 4
+
+class _3ds_short(object):
+	'''Class representing a short (2-byte integer) for a 3ds file.
+	*** This looks like an unsigned short H is unsigned from the struct docs - Cam***'''
+	__slots__ = 'value'
+	def __init__(self, val=0):
+		self.value=val
+	
+	def get_size(self):
+		return SZ_SHORT
+
+	def write(self,file):
+		file.write(struct.pack("<H", self.value))
+		
+	def __str__(self):
+		return str(self.value)
+
+class _3ds_int(object):
+	'''Class representing an int (4-byte integer) for a 3ds file.'''
+	__slots__ = 'value'
+	def __init__(self, val=0):
+		self.value=val
+	
+	def get_size(self):
+		return SZ_INT
+
+	def write(self,file):
+		file.write(struct.pack("<I", self.value))
+	
+	def __str__(self):
+		return str(self.value)
+
+class _3ds_float(object):
+	'''Class representing a 4-byte IEEE floating point number for a 3ds file.'''
+	__slots__ = 'value'
+	def __init__(self, val=0.0):
+		self.value=val
+	
+	def get_size(self):
+		return SZ_FLOAT
+
+	def write(self,file):
+		file.write(struct.pack("<f", self.value))
+	
+	def __str__(self):
+		return str(self.value)
+
+
+class _3ds_string(object):
+	'''Class representing a zero-terminated string for a 3ds file.'''
+	__slots__ = 'value'
+	def __init__(self, val=""):
+		self.value=val
+	
+	def get_size(self):
+		return (len(self.value)+1)
+
+	def write(self,file):
+		binary_format = "<%ds" % (len(self.value)+1)
+		file.write(struct.pack(binary_format, self.value))
+	
+	def __str__(self):
+		return self.value
+
+class _3ds_point_3d(object):
+	'''Class representing a three-dimensional point for a 3ds file.'''
+	__slots__ = 'x','y','z'
+	def __init__(self, point=(0.0,0.0,0.0)):
+		self.x, self.y, self.z = point
+		
+	def get_size(self):
+		return 3*SZ_FLOAT
+
+	def write(self,file):
+		file.write(struct.pack('<3f', self.x, self.y, self.z))
+	
+	def __str__(self):
+		return '(%f, %f, %f)' % (self.x, self.y, self.z)
+		
+# Used for writing a track
+"""
+class _3ds_point_4d(object):
+	'''Class representing a four-dimensional point for a 3ds file, for instance a quaternion.'''
+	__slots__ = 'x','y','z','w'
+	def __init__(self, point=(0.0,0.0,0.0,0.0)):
+		self.x, self.y, self.z, self.w = point	
+	
+	def get_size(self):
+		return 4*SZ_FLOAT
+
+	def write(self,file):
+		data=struct.pack('<4f', self.x, self.y, self.z, self.w)
+		file.write(data)
+
+	def __str__(self):
+		return '(%f, %f, %f, %f)' % (self.x, self.y, self.z, self.w)
+"""
+
+class _3ds_point_uv(object):
+	'''Class representing a UV-coordinate for a 3ds file.'''
+	__slots__ = 'uv'
+	def __init__(self, point=(0.0,0.0)):
+		self.uv = point
+	
+	def __cmp__(self, other):
+		return cmp(self.uv,other.uv)	
+	
+	def get_size(self):
+		return 2*SZ_FLOAT
+	
+	def write(self,file):
+		data=struct.pack('<2f', self.uv[0], self.uv[1])
+		file.write(data)
+	
+	def __str__(self):
+		return '(%g, %g)' % self.uv
+
+class _3ds_rgb_color(object):
+	'''Class representing a (24-bit) rgb color for a 3ds file.'''
+	__slots__ = 'r','g','b'
+	def __init__(self, col=(0,0,0)):
+		self.r, self.g, self.b = col
+	
+	def get_size(self):
+		return 3
+	
+	def write(self,file):
+		file.write( struct.pack('<3c', chr(int(255*self.r)), chr(int(255*self.g)), chr(int(255*self.b)) ) )
+	
+	def __str__(self):
+		return '{%f, %f, %f}' % (self.r, self.g, self.b)
+
+class _3ds_face(object):
+	'''Class representing a face for a 3ds file.'''
+	__slots__ = 'vindex'
+	def __init__(self, vindex):
+		self.vindex = vindex
+	
+	def get_size(self):
+		return 4*SZ_SHORT
+	
+	def write(self,file):
+		# The last zero is only used by 3d studio
+		file.write(struct.pack("<4H", self.vindex[0],self.vindex[1], self.vindex[2], 0))
+	
+	def __str__(self):
+		return '[%d %d %d]' % (self.vindex[0],self.vindex[1], self.vindex[2])
+
+class _3ds_array(object):
+	'''Class representing an array of variables for a 3ds file.
+
+	Consists of a _3ds_short to indicate the number of items, followed by the items themselves.
+	'''
+	__slots__ = 'values', 'size'
+	def __init__(self):
+		self.values=[]
+		self.size=SZ_SHORT
+	
+	# add an item:
+	def add(self,item):
+		self.values.append(item)
+		self.size+=item.get_size()
+	
+	def get_size(self):
+		return self.size
+	
+	def write(self,file):
+		_3ds_short(len(self.values)).write(file)
+		#_3ds_int(len(self.values)).write(file)
+		for value in self.values:
+			value.write(file)
+	
+	# To not overwhelm the output in a dump, a _3ds_array only
+	# outputs the number of items, not all of the actual items. 
+	def __str__(self):
+		return '(%d items)' % len(self.values)
+
+class _3ds_named_variable(object):
+	'''Convenience class for named variables.'''
+	
+	__slots__ = 'value', 'name'
+	def __init__(self, name, val=None):
+		self.name=name
+		self.value=val
+	
+	def get_size(self):
+		if (self.value==None): 
+			return 0
+		else:
+			return self.value.get_size()
+	
+	def write(self, file):
+		if (self.value!=None): 
+			self.value.write(file)
+	
+	def dump(self,indent):
+		if (self.value!=None):
+			spaces=""
+			for i in xrange(indent):
+				spaces+="  ";
+			if (self.name!=""):
+				print spaces, self.name, " = ", self.value
+			else:
+				print spaces, "[unnamed]", " = ", self.value
+
+
+#the chunk class
+class _3ds_chunk(object):
+	'''Class representing a chunk in a 3ds file.
+
+	Chunks contain zero or more variables, followed by zero or more subchunks.
+	'''
+	__slots__ = 'ID', 'size', 'variables', 'subchunks'
+	def __init__(self, id=0):
+		self.ID=_3ds_short(id)
+		self.size=_3ds_int(0)
+		self.variables=[]
+		self.subchunks=[]
+	
+	def set_ID(id):
+		self.ID=_3ds_short(id)
+	
+	def add_variable(self, name, var):
+		'''Add a named variable. 
+		
+		The name is mostly for debugging purposes.'''
+		self.variables.append(_3ds_named_variable(name,var))
+	
+	def add_subchunk(self, chunk):
+		'''Add a subchunk.'''
+		self.subchunks.append(chunk)
+
+	def get_size(self):
+		'''Calculate the size of the chunk and return it.
+		
+		The sizes of the variables and subchunks are used to determine this chunk\'s size.'''
+		tmpsize=self.ID.get_size()+self.size.get_size()
+		for variable in self.variables:
+			tmpsize+=variable.get_size()
+		for subchunk in self.subchunks:
+			tmpsize+=subchunk.get_size()
+		self.size.value=tmpsize
+		return self.size.value
+
+	def write(self, file):
+		'''Write the chunk to a file.
+		
+		Uses the write function of the variables and the subchunks to do the actual work.'''
+		#write header
+		self.ID.write(file)
+		self.size.write(file)
+		for variable in self.variables:
+			variable.write(file)
+		for subchunk in self.subchunks:
+			subchunk.write(file)
+		
+		
+	def dump(self, indent=0):
+		'''Write the chunk to a file.
+		
+		Dump is used for debugging purposes, to dump the contents of a chunk to the standard output. 
+		Uses the dump function of the named variables and the subchunks to do the actual work.'''
+		spaces=""
+		for i in xrange(indent):
+			spaces+="  ";
+		print spaces, "ID=", hex(self.ID.value), "size=", self.get_size()
+		for variable in self.variables:
+			variable.dump(indent+1)
+		for subchunk in self.subchunks:
+			subchunk.dump(indent+1)
+
+
+
+######################################################
+# EXPORT
+######################################################
+
+def get_material_images(material):
+	# blender utility func.
+	images = []
+	if material:
+		for mtex in material.getTextures():
+			if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
+				image = mtex.tex.image
+				if image:
+					images.append(image) # maye want to include info like diffuse, spec here.
+	return images
+
+def make_material_subchunk(id, color):
+	'''Make a material subchunk.
+	
+	Used for color subchunks, such as diffuse color or ambient color subchunks.'''
+	mat_sub = _3ds_chunk(id)
+	col1 = _3ds_chunk(RGB1)
+	col1.add_variable("color1", _3ds_rgb_color(color));
+	mat_sub.add_subchunk(col1)
+# optional:
+#	col2 = _3ds_chunk(RGB1)
+#	col2.add_variable("color2", _3ds_rgb_color(color));
+#	mat_sub.add_subchunk(col2)
+	return mat_sub
+
+
+def make_material_texture_chunk(id, images):
+	"""Make Material Map texture chunk
+	"""
+	mat_sub = _3ds_chunk(id)
+	
+	def add_image(img):
+		filename = image.filename.split('\\')[-1].split('/')[-1]
+		mat_sub_file = _3ds_chunk(MATMAPFILE)
+		mat_sub_file.add_variable("mapfile", _3ds_string(sane_name(filename)))
+		mat_sub.add_subchunk(mat_sub_file)
+	
+	for image in images:
+		add_image(image)
+	
+	return mat_sub
+
+def make_material_chunk(material, image):
+	'''Make a material chunk out of a blender material.'''
+	material_chunk = _3ds_chunk(MATERIAL)
+	name = _3ds_chunk(MATNAME)
+	
+	if material:	name_str = material.name
+	else:			name_str = 'None'
+	if image:	name_str += image.name
+		
+	name.add_variable("name", _3ds_string(sane_name(name_str)))
+	material_chunk.add_subchunk(name)
+	
+	if not material:
+		material_chunk.add_subchunk(make_material_subchunk(MATAMBIENT, (0,0,0) ))
+		material_chunk.add_subchunk(make_material_subchunk(MATDIFFUSE, (.8, .8, .8) ))
+		material_chunk.add_subchunk(make_material_subchunk(MATSPECULAR, (1,1,1) ))
+	
+	else:
+		material_chunk.add_subchunk(make_material_subchunk(MATAMBIENT, [a*material.amb for a in material.rgbCol] ))
+		material_chunk.add_subchunk(make_material_subchunk(MATDIFFUSE, material.rgbCol))
+		material_chunk.add_subchunk(make_material_subchunk(MATSPECULAR, material.specCol))
+		
+		images = get_material_images(material) # can be None
+		if image: images.append(image)
+		
+		if images:
+			material_chunk.add_subchunk(make_material_texture_chunk(MATMAP, images))
+	
+	return material_chunk
+
+class tri_wrapper(object):
+	'''Class representing a triangle.
+	
+	Used when converting faces to triangles'''
+	
+	__slots__ = 'vertex_index', 'mat', 'image', 'faceuvs', 'offset'
+	def __init__(self, vindex=(0,0,0), mat=None, image=None, faceuvs=None):
+		self.vertex_index= vindex
+		self.mat= mat
+		self.image= image
+		self.faceuvs= faceuvs
+		self.offset= [0, 0, 0] # offset indicies
+
+
+def extract_triangles(mesh):
+	'''Extract triangles from a mesh.
+	
+	If the mesh contains quads, they will be split into triangles.'''
+	tri_list = []
+	do_uv = mesh.faceUV
+	
+	if not do_uv:
+		face_uv = None
+	
+	img = None
+	for face in mesh.faces:
+		f_v = face.v
+		
+		if do_uv:
+			f_uv = face.uv
+			img = face.image
+			if img: img = img.name
+		
+		if len(f_v)==3:
+			new_tri = tri_wrapper((f_v[0].index, f_v[1].index, f_v[2].index), face.mat, img)
+			if (do_uv): new_tri.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[1]), uv_key(f_uv[2])
+			tri_list.append(new_tri)
+		
+		else: #it's a quad
+			new_tri = tri_wrapper((f_v[0].index, f_v[1].index, f_v[2].index), face.mat, img)
+			new_tri_2 = tri_wrapper((f_v[0].index, f_v[2].index, f_v[3].index), face.mat, img)
+			
+			if (do_uv):
+				new_tri.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[1]), uv_key(f_uv[2])
+				new_tri_2.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[2]), uv_key(f_uv[3])
+			
+			tri_list.append( new_tri )
+			tri_list.append( new_tri_2 )
+		
+	return tri_list
+	
+	
+def remove_face_uv(verts, tri_list):
+	'''Remove face UV coordinates from a list of triangles.
+		
+	Since 3ds files only support one pair of uv coordinates for each vertex, face uv coordinates
+	need to be converted to vertex uv coordinates. That means that vertices need to be duplicated when
+	there are multiple uv coordinates per vertex.'''
+	
+	# initialize a list of UniqueLists, one per vertex:
+	#uv_list = [UniqueList() for i in xrange(len(verts))]
+	unique_uvs= [{} for i in xrange(len(verts))]
+	
+	# for each face uv coordinate, add it to the UniqueList of the vertex
+	for tri in tri_list:
+		for i in xrange(3):
+			# store the index into the UniqueList for future reference:
+			# offset.append(uv_list[tri.vertex_index[i]].add(_3ds_point_uv(tri.faceuvs[i])))
+			
+			context_uv_vert= unique_uvs[tri.vertex_index[i]]
+			uvkey= tri.faceuvs[i]
+			
+			offset_index__uv_3ds = context_uv_vert.get(uvkey)
+			
+			if not offset_index__uv_3ds:				
+				offset_index__uv_3ds = context_uv_vert[uvkey] = len(context_uv_vert), _3ds_point_uv(uvkey)
+			
+			tri.offset[i] = offset_index__uv_3ds[0]
+			
+			
+		
+	# At this point, each vertex has a UniqueList containing every uv coordinate that is associated with it
+	# only once.
+	
+	# Now we need to duplicate every vertex as many times as it has uv coordinates and make sure the
+	# faces refer to the new face indices:
+	vert_index = 0
+	vert_array = _3ds_array()
+	uv_array = _3ds_array()
+	index_list = []
+	for i,vert in enumerate(verts):
+		index_list.append(vert_index)
+		
+		pt = _3ds_point_3d(vert.co) # reuse, should be ok
+		uvmap = [None] * len(unique_uvs[i])
+		for ii, uv_3ds in unique_uvs[i].itervalues():
+			# add a vertex duplicate to the vertex_array for every uv associated with this vertex:
+			vert_array.add(pt)
+			# add the uv coordinate to the uv array:
+			# This for loop does not give uv's ordered by ii, so we create a new map
+			# and add the uv's later
+			# uv_array.add(uv_3ds)
+			uvmap[ii] = uv_3ds
+		
+		# Add the uv's in the correct order
+		for uv_3ds in uvmap:
+			# add the uv coordinate to the uv array:
+			uv_array.add(uv_3ds)
+		
+		vert_index += len(unique_uvs[i])
+	
+	# Make sure the triangle vertex indices now refer to the new vertex list:
+	for tri in tri_list:
+		for i in xrange(3):
+			tri.offset[i]+=index_list[tri.vertex_index[i]]
+		tri.vertex_index= tri.offset
+	
+	return vert_array, uv_array, tri_list
+
+def make_faces_chunk(tri_list, mesh, materialDict):
+	'''Make a chunk for the faces.
+	
+	Also adds subchunks assigning materials to all faces.'''
+	
+	materials = mesh.materials
+	if not materials:
+		mat = None
+	
+	face_chunk = _3ds_chunk(OBJECT_FACES)
+	face_list = _3ds_array()
+	
+	
+	if mesh.faceUV:
+		# Gather materials used in this mesh - mat/image pairs
+		unique_mats = {}
+		for i,tri in enumerate(tri_list):
+			
+			face_list.add(_3ds_face(tri.vertex_index))
+			
+			if materials:
+				mat = materials[tri.mat]
+				if mat: mat = mat.name
+			
+			img = tri.image
+			
+			try:
+				context_mat_face_array = unique_mats[mat, img][1]
+			except:
+				
+				if mat:	name_str = mat
+				else:	name_str = 'None'
+				if img: name_str += img
+				
+				context_mat_face_array = _3ds_array()
+				unique_mats[mat, img] = _3ds_string(sane_name(name_str)), context_mat_face_array
+				
+			
+			context_mat_face_array.add(_3ds_short(i))
+			# obj_material_faces[tri.mat].add(_3ds_short(i))
+		
+		face_chunk.add_variable("faces", face_list)
+		for mat_name, mat_faces in unique_mats.itervalues():
+			obj_material_chunk=_3ds_chunk(OBJECT_MATERIAL)
+			obj_material_chunk.add_variable("name", mat_name)
+			obj_material_chunk.add_variable("face_list", mat_faces)
+			face_chunk.add_subchunk(obj_material_chunk)
+			
+	else:
+		
+		obj_material_faces=[]
+		obj_material_names=[]
+		for m in materials:
+			if m:
+				obj_material_names.append(_3ds_string(sane_name(m.name)))
+				obj_material_faces.append(_3ds_array())
+		n_materials = len(obj_material_names)
+		
+		for i,tri in enumerate(tri_list):
+			face_list.add(_3ds_face(tri.vertex_index))
+			if (tri.mat < n_materials):
+				obj_material_faces[tri.mat].add(_3ds_short(i))
+		
+		face_chunk.add_variable("faces", face_list)
+		for i in xrange(n_materials):
+			obj_material_chunk=_3ds_chunk(OBJECT_MATERIAL)
+			obj_material_chunk.add_variable("name", obj_material_names[i])
+			obj_material_chunk.add_variable("face_list", obj_material_faces[i])
+			face_chunk.add_subchunk(obj_material_chunk)
+	
+	return face_chunk
+
+def make_vert_chunk(vert_array):
+	'''Make a vertex chunk out of an array of vertices.'''
+	vert_chunk = _3ds_chunk(OBJECT_VERTICES)
+	vert_chunk.add_variable("vertices",vert_array)
+	return vert_chunk
+
+def make_uv_chunk(uv_array):
+	'''Make a UV chunk out of an array of UVs.'''
+	uv_chunk = _3ds_chunk(OBJECT_UV)
+	uv_chunk.add_variable("uv coords", uv_array)
+	return uv_chunk
+
+def make_mesh_chunk(mesh, materialDict):
+	'''Make a chunk out of a Blender mesh.'''
+	
+	# Extract the triangles from the mesh:
+	tri_list = extract_triangles(mesh)
+	
+	if mesh.faceUV:
+		# Remove the face UVs and convert it to vertex UV:
+		vert_array, uv_array, tri_list = remove_face_uv(mesh.verts, tri_list)
+	else:
+		# Add the vertices to the vertex array:
+		vert_array = _3ds_array()
+		for vert in mesh.verts:
+			vert_array.add(_3ds_point_3d(vert.co))
+		# If the mesh has vertex UVs, create an array of UVs:
+		if mesh.vertexUV:
+			uv_array = _3ds_array()
+			for vert in mesh.verts:
+				uv_array.add(_3ds_point_uv(vert.uvco))
+		else:
+			# no UV at all:
+			uv_array = None
+
+	# create the chunk:
+	mesh_chunk = _3ds_chunk(OBJECT_MESH)
+	
+	# add vertex chunk:
+	mesh_chunk.add_subchunk(make_vert_chunk(vert_array))
+	# add faces chunk:
+	
+	mesh_chunk.add_subchunk(make_faces_chunk(tri_list, mesh, materialDict))
+	
+	# if available, add uv chunk:
+	if uv_array:
+		mesh_chunk.add_subchunk(make_uv_chunk(uv_array))
+	
+	return mesh_chunk
+
+""" # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+def make_kfdata(start=0, stop=0, curtime=0):
+	'''Make the basic keyframe data chunk'''
+	kfdata = _3ds_chunk(KFDATA)
+	
+	kfhdr = _3ds_chunk(KFDATA_KFHDR)
+	kfhdr.add_variable("revision", _3ds_short(0))
+	# Not really sure what filename is used for, but it seems it is usually used
+	# to identify the program that generated the .3ds:
+	kfhdr.add_variable("filename", _3ds_string("Blender"))
+	kfhdr.add_variable("animlen", _3ds_int(stop-start))
+	
+	kfseg = _3ds_chunk(KFDATA_KFSEG)
+	kfseg.add_variable("start", _3ds_int(start))
+	kfseg.add_variable("stop", _3ds_int(stop))
+	
+	kfcurtime = _3ds_chunk(KFDATA_KFCURTIME)
+	kfcurtime.add_variable("curtime", _3ds_int(curtime))
+	
+	kfdata.add_subchunk(kfhdr)
+	kfdata.add_subchunk(kfseg)
+	kfdata.add_subchunk(kfcurtime)
+	return kfdata
+"""
+
+"""
+def make_track_chunk(ID, obj):
+	'''Make a chunk for track data.
+	
+	Depending on the ID, this will construct a position, rotation or scale track.'''
+	track_chunk = _3ds_chunk(ID)
+	track_chunk.add_variable("track_flags", _3ds_short())
+	track_chunk.add_variable("unknown", _3ds_int())
+	track_chunk.add_variable("unknown", _3ds_int())
+	track_chunk.add_variable("nkeys", _3ds_int(1))
+	# Next section should be repeated for every keyframe, but for now, animation is not actually supported.
+	track_chunk.add_variable("tcb_frame", _3ds_int(0))
+	track_chunk.add_variable("tcb_flags", _3ds_short())
+	if obj.type=='Empty':
+		if ID==POS_TRACK_TAG:
+			# position vector:
+			track_chunk.add_variable("position", _3ds_point_3d(obj.getLocation()))
+		elif ID==ROT_TRACK_TAG:
+			# rotation (quaternion, angle first, followed by axis):
+			q = obj.getEuler().toQuat()
+			track_chunk.add_variable("rotation", _3ds_point_4d((q.angle, q.axis[0], q.axis[1], q.axis[2])))
+		elif ID==SCL_TRACK_TAG:
+			# scale vector:
+			track_chunk.add_variable("scale", _3ds_point_3d(obj.getSize()))
+	else:
+		# meshes have their transformations applied before 
+		# exporting, so write identity transforms here:
+		if ID==POS_TRACK_TAG:
+			# position vector:
+			track_chunk.add_variable("position", _3ds_point_3d((0.0,0.0,0.0)))
+		elif ID==ROT_TRACK_TAG:
+			# rotation (quaternion, angle first, followed by axis):
+			track_chunk.add_variable("rotation", _3ds_point_4d((0.0, 1.0, 0.0, 0.0)))
+		elif ID==SCL_TRACK_TAG:
+			# scale vector:
+			track_chunk.add_variable("scale", _3ds_point_3d((1.0, 1.0, 1.0)))
+	
+	return track_chunk
+"""
+
+"""
+def make_kf_obj_node(obj, name_to_id):
+	'''Make a node chunk for a Blender object.
+	
+	Takes the Blender object as a parameter. Object id's are taken from the dictionary name_to_id.
+	Blender Empty objects are converted to dummy nodes.'''
+	
+	name = obj.name
+	# main object node chunk:
+	kf_obj_node = _3ds_chunk(KFDATA_OBJECT_NODE_TAG)
+	# chunk for the object id: 
+	obj_id_chunk = _3ds_chunk(OBJECT_NODE_ID)
+	# object id is from the name_to_id dictionary:
+	obj_id_chunk.add_variable("node_id", _3ds_short(name_to_id[name]))
+	
+	# object node header:
+	obj_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR)
+	# object name:
+	if obj.type == 'Empty':
+		# Empties are called "$$$DUMMY" and use the OBJECT_INSTANCE_NAME chunk 
+		# for their name (see below):
+		obj_node_header_chunk.add_variable("name", _3ds_string("$$$DUMMY"))
+	else:
+		# Add the name:
+		obj_node_header_chunk.add_variable("name", _3ds_string(sane_name(name)))
+	# Add Flag variables (not sure what they do):
+	obj_node_header_chunk.add_variable("flags1", _3ds_short(0))
+	obj_node_header_chunk.add_variable("flags2", _3ds_short(0))
+	
+	# Check parent-child relationships:
+	parent = obj.parent
+	if (parent == None) or (parent.name not in name_to_id):
+		# If no parent, or the parents name is not in the name_to_id dictionary,
+		# parent id becomes -1:
+		obj_node_header_chunk.add_variable("parent", _3ds_short(-1))
+	else:
+		# Get the parent's id from the name_to_id dictionary:
+		obj_node_header_chunk.add_variable("parent", _3ds_short(name_to_id[parent.name]))
+	
+	# Add pivot chunk:
+	obj_pivot_chunk = _3ds_chunk(OBJECT_PIVOT)
+	obj_pivot_chunk.add_variable("pivot", _3ds_point_3d(obj.getLocation()))
+	kf_obj_node.add_subchunk(obj_pivot_chunk)
+	
+	# add subchunks for object id and node header:
+	kf_obj_node.add_subchunk(obj_id_chunk)
+	kf_obj_node.add_subchunk(obj_node_header_chunk)
+
+	# Empty objects need to have an extra chunk for the instance name:
+	if obj.type == 'Empty':
+		obj_instance_name_chunk = _3ds_chunk(OBJECT_INSTANCE_NAME)
+		obj_instance_name_chunk.add_variable("name", _3ds_string(sane_name(name)))
+		kf_obj_node.add_subchunk(obj_instance_name_chunk)
+	
+	# Add track chunks for position, rotation and scale:
+	kf_obj_node.add_subchunk(make_track_chunk(POS_TRACK_TAG, obj))
+	kf_obj_node.add_subchunk(make_track_chunk(ROT_TRACK_TAG, obj))
+	kf_obj_node.add_subchunk(make_track_chunk(SCL_TRACK_TAG, obj))
+
+	return kf_obj_node
+"""
+
+import BPyMessages
+def save_3ds(filename):
+	'''Save the Blender scene to a 3ds file.'''
+	# Time the export
+	
+	if not filename.lower().endswith('.3ds'):
+		filename += '.3ds'
+	
+	# if not BPyMessages.Warning_SaveOver(filename):
+	# 	return
+	
+	time1= Blender.sys.time()
+	Blender.Window.WaitCursor(1)
+	sce= bpy.data.scenes.active
+	
+	# Initialize the main chunk (primary):
+	primary = _3ds_chunk(PRIMARY)
+	# Add version chunk:
+	version_chunk = _3ds_chunk(VERSION)
+	version_chunk.add_variable("version", _3ds_int(3))
+	primary.add_subchunk(version_chunk)
+	
+	# init main object info chunk:
+	object_info = _3ds_chunk(OBJECTINFO)
+	
+	''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+	# init main key frame data chunk:
+	kfdata = make_kfdata()
+	'''
+	
+	# Get all the supported objects selected in this scene:
+	# ob_sel= list(sce.objects.context)
+	# mesh_objects = [ (ob, me) for ob in ob_sel   for me in (BPyMesh.getMeshFromObject(ob, None, True, False, sce),) if me ]
+	# empty_objects = [ ob for ob in ob_sel if ob.type == 'Empty' ]
+	
+	# Make a list of all materials used in the selected meshes (use a dictionary,
+	# each material is added once):
+	materialDict = {}
+	mesh_objects = []
+	for ob in sce.objects.context:
+		for ob_derived, mat in getDerivedObjects(ob, False):
+			data = getMeshFromObject(ob_derived, None, True, False, sce)
+			if data:
+				data.transform(mat, recalc_normals=False)
+				mesh_objects.append((ob_derived, data))
+				mat_ls = data.materials
+				mat_ls_len = len(mat_ls)
+				# get material/image tuples.
+				if data.faceUV:
+					if not mat_ls:
+						mat = mat_name = None
+					
+					for f in data.faces:
+						if mat_ls:
+							mat_index = f.mat
+							if mat_index >= mat_ls_len:
+								mat_index = f.mat = 0
+							mat = mat_ls[mat_index]
+							if mat:	mat_name = mat.name
+							else:	mat_name = None
+						# else there alredy set to none
+							
+						img = f.image
+						if img:	img_name = img.name
+						else:	img_name = None
+						
+						materialDict.setdefault((mat_name, img_name), (mat, img) )
+						
+					
+				else:
+					for mat in mat_ls:
+						if mat: # material may be None so check its not.
+							materialDict.setdefault((mat.name, None), (mat, None) )
+					
+					# Why 0 Why!
+					for f in data.faces:
+						if f.mat >= mat_ls_len:
+							f.mat = 0 
+	
+	# Make material chunks for all materials used in the meshes:
+	for mat_and_image in materialDict.itervalues():
+		object_info.add_subchunk(make_material_chunk(mat_and_image[0], mat_and_image[1]))
+	
+	# Give all objects a unique ID and build a dictionary from object name to object id:
+	"""
+	name_to_id = {}
+	for ob, data in mesh_objects:
+		name_to_id[ob.name]= len(name_to_id)
+	#for ob in empty_objects:
+	#	name_to_id[ob.name]= len(name_to_id)
+	"""
+	
+	# Create object chunks for all meshes:
+	i = 0
+	for ob, blender_mesh in mesh_objects:
+		# create a new object chunk
+		object_chunk = _3ds_chunk(OBJECT)
+		
+		# set the object name
+		object_chunk.add_variable("name", _3ds_string(sane_name(ob.name)))
+		
+		# make a mesh chunk out of the mesh:
+		object_chunk.add_subchunk(make_mesh_chunk(blender_mesh, materialDict))
+		object_info.add_subchunk(object_chunk)
+		
+		''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+		# make a kf object node for the object:
+		kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id))
+		'''
+		blender_mesh.verts = None
+		i+=i
+
+	# Create chunks for all empties:
+	''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+	for ob in empty_objects:
+		# Empties only require a kf object node:
+		kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id))
+		pass
+	'''
+	
+	# Add main object info chunk to primary chunk:
+	primary.add_subchunk(object_info)
+	
+	''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+	# Add main keyframe data chunk to primary chunk:
+	primary.add_subchunk(kfdata)
+	'''
+	
+	# At this point, the chunk hierarchy is completely built.
+	
+	# Check the size:
+	primary.get_size()
+	# Open the file for writing:
+	file = open( filename, 'wb' )
+	
+	# Recursively write the chunks to file:
+	primary.write(file)
+	
+	# Close the file:
+	file.close()
+	
+	# Debugging only: report the exporting time:
+	Blender.Window.WaitCursor(0)
+	print "3ds export time: %.2f" % (Blender.sys.time() - time1)
+	
+	# Debugging only: dump the chunk hierarchy:
+	#primary.dump()
+
+save_3ds( Blender.Get('tempdir') + '/tmp_scene_freestyle.3ds' )
diff --git a/source/blender/freestyle/python/Freestyle.py b/source/blender/freestyle/python/Freestyle.py
new file mode 100755
index 00000000000..e4b81a7d071
--- /dev/null
+++ b/source/blender/freestyle/python/Freestyle.py
@@ -0,0 +1,4964 @@
+# This file was automatically generated by SWIG (http://www.swig.org).
+# Version 1.3.31
+#
+# Don't modify this file, modify the SWIG interface instead.
+# This file is compatible with both classic and new-style classes.
+
+import _Freestyle
+import new
+new_instancemethod = new.instancemethod
+try:
+    _swig_property = property
+except NameError:
+    pass # Python < 2.2 doesn't have 'property'.
+def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+    if (name == "thisown"): return self.this.own(value)
+    if (name == "this"):
+        if type(value).__name__ == 'PySwigObject':
+            self.__dict__[name] = value
+            return
+    method = class_type.__swig_setmethods__.get(name,None)
+    if method: return method(self,value)
+    if (not static) or hasattr(self,name):
+        self.__dict__[name] = value
+    else:
+        raise AttributeError("You cannot add attributes to %s" % self)
+
+def _swig_setattr(self,class_type,name,value):
+    return _swig_setattr_nondynamic(self,class_type,name,value,0)
+
+def _swig_getattr(self,class_type,name):
+    if (name == "thisown"): return self.this.own()
+    method = class_type.__swig_getmethods__.get(name,None)
+    if method: return method(self)
+    raise AttributeError,name
+
+def _swig_repr(self):
+    try: strthis = "proxy of " + self.this.__repr__()
+    except: strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+import types
+try:
+    _object = types.ObjectType
+    _newclass = 1
+except AttributeError:
+    class _object : pass
+    _newclass = 0
+del types
+
+
+try:
+    import weakref
+    weakref_proxy = weakref.proxy
+except:
+    weakref_proxy = lambda x: x
+
+
+class PySwigIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr
+    __swig_destroy__ = _Freestyle.delete_PySwigIterator
+    __del__ = lambda self : None;
+    def value(*args): return _Freestyle.PySwigIterator_value(*args)
+    def incr(*args): return _Freestyle.PySwigIterator_incr(*args)
+    def decr(*args): return _Freestyle.PySwigIterator_decr(*args)
+    def distance(*args): return _Freestyle.PySwigIterator_distance(*args)
+    def equal(*args): return _Freestyle.PySwigIterator_equal(*args)
+    def copy(*args): return _Freestyle.PySwigIterator_copy(*args)
+    def next(*args): return _Freestyle.PySwigIterator_next(*args)
+    def previous(*args): return _Freestyle.PySwigIterator_previous(*args)
+    def advance(*args): return _Freestyle.PySwigIterator_advance(*args)
+    def __eq__(*args): return _Freestyle.PySwigIterator___eq__(*args)
+    def __ne__(*args): return _Freestyle.PySwigIterator___ne__(*args)
+    def __iadd__(*args): return _Freestyle.PySwigIterator___iadd__(*args)
+    def __isub__(*args): return _Freestyle.PySwigIterator___isub__(*args)
+    def __add__(*args): return _Freestyle.PySwigIterator___add__(*args)
+    def __sub__(*args): return _Freestyle.PySwigIterator___sub__(*args)
+    def __iter__(self): return self
+PySwigIterator_swigregister = _Freestyle.PySwigIterator_swigregister
+PySwigIterator_swigregister(PySwigIterator)
+
+class vectorInt(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorInt, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, vectorInt, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.vectorInt_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.vectorInt___nonzero__(*args)
+    def __len__(*args): return _Freestyle.vectorInt___len__(*args)
+    def pop(*args): return _Freestyle.vectorInt_pop(*args)
+    def __getslice__(*args): return _Freestyle.vectorInt___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.vectorInt___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.vectorInt___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.vectorInt___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.vectorInt___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.vectorInt___setitem__(*args)
+    def append(*args): return _Freestyle.vectorInt_append(*args)
+    def empty(*args): return _Freestyle.vectorInt_empty(*args)
+    def size(*args): return _Freestyle.vectorInt_size(*args)
+    def clear(*args): return _Freestyle.vectorInt_clear(*args)
+    def swap(*args): return _Freestyle.vectorInt_swap(*args)
+    def get_allocator(*args): return _Freestyle.vectorInt_get_allocator(*args)
+    def begin(*args): return _Freestyle.vectorInt_begin(*args)
+    def end(*args): return _Freestyle.vectorInt_end(*args)
+    def rbegin(*args): return _Freestyle.vectorInt_rbegin(*args)
+    def rend(*args): return _Freestyle.vectorInt_rend(*args)
+    def pop_back(*args): return _Freestyle.vectorInt_pop_back(*args)
+    def erase(*args): return _Freestyle.vectorInt_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_vectorInt(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.vectorInt_push_back(*args)
+    def front(*args): return _Freestyle.vectorInt_front(*args)
+    def back(*args): return _Freestyle.vectorInt_back(*args)
+    def assign(*args): return _Freestyle.vectorInt_assign(*args)
+    def resize(*args): return _Freestyle.vectorInt_resize(*args)
+    def insert(*args): return _Freestyle.vectorInt_insert(*args)
+    def reserve(*args): return _Freestyle.vectorInt_reserve(*args)
+    def capacity(*args): return _Freestyle.vectorInt_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_vectorInt
+    __del__ = lambda self : None;
+vectorInt_swigregister = _Freestyle.vectorInt_swigregister
+vectorInt_swigregister(vectorInt)
+
+class Id(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Id, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Id, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Id(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getFirst(*args): return _Freestyle.Id_getFirst(*args)
+    def getSecond(*args): return _Freestyle.Id_getSecond(*args)
+    def setFirst(*args): return _Freestyle.Id_setFirst(*args)
+    def setSecond(*args): return _Freestyle.Id_setSecond(*args)
+    def __eq__(*args): return _Freestyle.Id___eq__(*args)
+    def __ne__(*args): return _Freestyle.Id___ne__(*args)
+    def __lt__(*args): return _Freestyle.Id___lt__(*args)
+    __swig_destroy__ = _Freestyle.delete_Id
+    __del__ = lambda self : None;
+Id_swigregister = _Freestyle.Id_swigregister
+Id_swigregister(Id)
+
+class Vec_2u(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_2u, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_2u, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_2u(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_2u
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_2u_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_2u_dim)
+    def norm(*args): return _Freestyle.Vec_2u_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_2u_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_2u_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_2u_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_2u___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_2u___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_2u___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_2u___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_2u___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_2u___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_2u___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_2u___gt__(*args)
+Vec_2u_swigregister = _Freestyle.Vec_2u_swigregister
+Vec_2u_swigregister(Vec_2u)
+Vec_2u_dim = _Freestyle.Vec_2u_dim
+
+class Vec_2i(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_2i, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_2i, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_2i(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_2i
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_2i_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_2i_dim)
+    def norm(*args): return _Freestyle.Vec_2i_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_2i_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_2i_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_2i_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_2i___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_2i___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_2i___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_2i___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_2i___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_2i___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_2i___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_2i___gt__(*args)
+Vec_2i_swigregister = _Freestyle.Vec_2i_swigregister
+Vec_2i_swigregister(Vec_2i)
+Vec_2i_dim = _Freestyle.Vec_2i_dim
+
+class Vec_2d(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_2d, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_2d, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_2d(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_2d
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_2d_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_2d_dim)
+    def norm(*args): return _Freestyle.Vec_2d_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_2d_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_2d_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_2d_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_2d___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_2d___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_2d___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_2d___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_2d___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_2d___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_2d___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_2d___gt__(*args)
+Vec_2d_swigregister = _Freestyle.Vec_2d_swigregister
+Vec_2d_swigregister(Vec_2d)
+Vec_2d_dim = _Freestyle.Vec_2d_dim
+
+class Vec_2f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_2f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_2f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_2f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_2f
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_2f_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_2f_dim)
+    def norm(*args): return _Freestyle.Vec_2f_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_2f_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_2f_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_2f_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_2f___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_2f___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_2f___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_2f___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_2f___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_2f___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_2f___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_2f___gt__(*args)
+Vec_2f_swigregister = _Freestyle.Vec_2f_swigregister
+Vec_2f_swigregister(Vec_2f)
+Vec_2f_dim = _Freestyle.Vec_2f_dim
+
+class Vec2u(Vec_2u):
+    __swig_setmethods__ = {}
+    for _s in [Vec_2u]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec2u, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_2u]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec2u, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec2u(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec2u_x(*args)
+    def y(*args): return _Freestyle.Vec2u_y(*args)
+    def setX(*args): return _Freestyle.Vec2u_setX(*args)
+    def setY(*args): return _Freestyle.Vec2u_setY(*args)
+    def __add__(*args): return _Freestyle.Vec2u___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec2u___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec2u___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec2u___mul__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec2u
+    __del__ = lambda self : None;
+Vec2u_swigregister = _Freestyle.Vec2u_swigregister
+Vec2u_swigregister(Vec2u)
+
+class Vec2i(Vec_2i):
+    __swig_setmethods__ = {}
+    for _s in [Vec_2i]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec2i, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_2i]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec2i, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec2i(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec2i_x(*args)
+    def y(*args): return _Freestyle.Vec2i_y(*args)
+    def setX(*args): return _Freestyle.Vec2i_setX(*args)
+    def setY(*args): return _Freestyle.Vec2i_setY(*args)
+    def __add__(*args): return _Freestyle.Vec2i___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec2i___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec2i___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec2i___mul__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec2i
+    __del__ = lambda self : None;
+Vec2i_swigregister = _Freestyle.Vec2i_swigregister
+Vec2i_swigregister(Vec2i)
+
+class Vec2f(Vec_2f):
+    __swig_setmethods__ = {}
+    for _s in [Vec_2f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec2f, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_2f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec2f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec2f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec2f_x(*args)
+    def y(*args): return _Freestyle.Vec2f_y(*args)
+    def setX(*args): return _Freestyle.Vec2f_setX(*args)
+    def setY(*args): return _Freestyle.Vec2f_setY(*args)
+    def __add__(*args): return _Freestyle.Vec2f___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec2f___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec2f___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec2f___mul__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec2f
+    __del__ = lambda self : None;
+Vec2f_swigregister = _Freestyle.Vec2f_swigregister
+Vec2f_swigregister(Vec2f)
+
+class Vec2d(Vec_2d):
+    __swig_setmethods__ = {}
+    for _s in [Vec_2d]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec2d, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_2d]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec2d, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec2d(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec2d_x(*args)
+    def y(*args): return _Freestyle.Vec2d_y(*args)
+    def setX(*args): return _Freestyle.Vec2d_setX(*args)
+    def setY(*args): return _Freestyle.Vec2d_setY(*args)
+    def __add__(*args): return _Freestyle.Vec2d___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec2d___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec2d___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec2d___mul__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec2d
+    __del__ = lambda self : None;
+Vec2d_swigregister = _Freestyle.Vec2d_swigregister
+Vec2d_swigregister(Vec2d)
+
+class Vec_3u(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_3u, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_3u, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_3u(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_3u
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_3u_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_3u_dim)
+    def norm(*args): return _Freestyle.Vec_3u_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_3u_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_3u_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_3u_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_3u___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_3u___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_3u___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_3u___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_3u___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_3u___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_3u___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_3u___gt__(*args)
+Vec_3u_swigregister = _Freestyle.Vec_3u_swigregister
+Vec_3u_swigregister(Vec_3u)
+Vec_3u_dim = _Freestyle.Vec_3u_dim
+
+class Vec_3i(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_3i, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_3i, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_3i(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_3i
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_3i_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_3i_dim)
+    def norm(*args): return _Freestyle.Vec_3i_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_3i_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_3i_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_3i_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_3i___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_3i___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_3i___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_3i___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_3i___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_3i___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_3i___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_3i___gt__(*args)
+Vec_3i_swigregister = _Freestyle.Vec_3i_swigregister
+Vec_3i_swigregister(Vec_3i)
+Vec_3i_dim = _Freestyle.Vec_3i_dim
+
+class Vec_3d(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_3d, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_3d, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_3d(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_3d
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_3d_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_3d_dim)
+    def norm(*args): return _Freestyle.Vec_3d_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_3d_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_3d_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_3d_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_3d___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_3d___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_3d___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_3d___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_3d___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_3d___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_3d___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_3d___gt__(*args)
+Vec_3d_swigregister = _Freestyle.Vec_3d_swigregister
+Vec_3d_swigregister(Vec_3d)
+Vec_3d_dim = _Freestyle.Vec_3d_dim
+
+class Vec_3f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec_3f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec_3f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec_3f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Vec_3f
+    __del__ = lambda self : None;
+    __swig_getmethods__["dim"] = lambda x: _Freestyle.Vec_3f_dim
+    if _newclass:dim = staticmethod(_Freestyle.Vec_3f_dim)
+    def norm(*args): return _Freestyle.Vec_3f_norm(*args)
+    def squareNorm(*args): return _Freestyle.Vec_3f_squareNorm(*args)
+    def normalize(*args): return _Freestyle.Vec_3f_normalize(*args)
+    def normalizeSafe(*args): return _Freestyle.Vec_3f_normalizeSafe(*args)
+    def __add__(*args): return _Freestyle.Vec_3f___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec_3f___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec_3f___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec_3f___mul__(*args)
+    def __eq__(*args): return _Freestyle.Vec_3f___eq__(*args)
+    def __ne__(*args): return _Freestyle.Vec_3f___ne__(*args)
+    def __lt__(*args): return _Freestyle.Vec_3f___lt__(*args)
+    def __gt__(*args): return _Freestyle.Vec_3f___gt__(*args)
+Vec_3f_swigregister = _Freestyle.Vec_3f_swigregister
+Vec_3f_swigregister(Vec_3f)
+Vec_3f_dim = _Freestyle.Vec_3f_dim
+
+class Vec3u(Vec_3u):
+    __swig_setmethods__ = {}
+    for _s in [Vec_3u]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3u, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_3u]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec3u, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec3u(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec3u_x(*args)
+    def y(*args): return _Freestyle.Vec3u_y(*args)
+    def z(*args): return _Freestyle.Vec3u_z(*args)
+    def setX(*args): return _Freestyle.Vec3u_setX(*args)
+    def setY(*args): return _Freestyle.Vec3u_setY(*args)
+    def setZ(*args): return _Freestyle.Vec3u_setZ(*args)
+    def __add__(*args): return _Freestyle.Vec3u___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec3u___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec3u___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec3u___mul__(*args)
+    def __xor__(*args): return _Freestyle.Vec3u___xor__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec3u
+    __del__ = lambda self : None;
+Vec3u_swigregister = _Freestyle.Vec3u_swigregister
+Vec3u_swigregister(Vec3u)
+
+class Vec3i(Vec_3i):
+    __swig_setmethods__ = {}
+    for _s in [Vec_3i]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3i, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_3i]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec3i, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec3i(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec3i_x(*args)
+    def y(*args): return _Freestyle.Vec3i_y(*args)
+    def z(*args): return _Freestyle.Vec3i_z(*args)
+    def setX(*args): return _Freestyle.Vec3i_setX(*args)
+    def setY(*args): return _Freestyle.Vec3i_setY(*args)
+    def setZ(*args): return _Freestyle.Vec3i_setZ(*args)
+    def __add__(*args): return _Freestyle.Vec3i___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec3i___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec3i___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec3i___mul__(*args)
+    def __xor__(*args): return _Freestyle.Vec3i___xor__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec3i
+    __del__ = lambda self : None;
+Vec3i_swigregister = _Freestyle.Vec3i_swigregister
+Vec3i_swigregister(Vec3i)
+
+class Vec3f(Vec_3f):
+    __swig_setmethods__ = {}
+    for _s in [Vec_3f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3f, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_3f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec3f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec3f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec3f_x(*args)
+    def y(*args): return _Freestyle.Vec3f_y(*args)
+    def z(*args): return _Freestyle.Vec3f_z(*args)
+    def setX(*args): return _Freestyle.Vec3f_setX(*args)
+    def setY(*args): return _Freestyle.Vec3f_setY(*args)
+    def setZ(*args): return _Freestyle.Vec3f_setZ(*args)
+    def __add__(*args): return _Freestyle.Vec3f___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec3f___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec3f___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec3f___mul__(*args)
+    def __xor__(*args): return _Freestyle.Vec3f___xor__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec3f
+    __del__ = lambda self : None;
+Vec3f_swigregister = _Freestyle.Vec3f_swigregister
+Vec3f_swigregister(Vec3f)
+
+class Vec3d(Vec_3d):
+    __swig_setmethods__ = {}
+    for _s in [Vec_3d]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec3d, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Vec_3d]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Vec3d, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Vec3d(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def x(*args): return _Freestyle.Vec3d_x(*args)
+    def y(*args): return _Freestyle.Vec3d_y(*args)
+    def z(*args): return _Freestyle.Vec3d_z(*args)
+    def setX(*args): return _Freestyle.Vec3d_setX(*args)
+    def setY(*args): return _Freestyle.Vec3d_setY(*args)
+    def setZ(*args): return _Freestyle.Vec3d_setZ(*args)
+    def __add__(*args): return _Freestyle.Vec3d___add__(*args)
+    def __sub__(*args): return _Freestyle.Vec3d___sub__(*args)
+    def __div__(*args): return _Freestyle.Vec3d___div__(*args)
+    def __mul__(*args): return _Freestyle.Vec3d___mul__(*args)
+    def __xor__(*args): return _Freestyle.Vec3d___xor__(*args)
+    __swig_destroy__ = _Freestyle.delete_Vec3d
+    __del__ = lambda self : None;
+Vec3d_swigregister = _Freestyle.Vec3d_swigregister
+Vec3d_swigregister(Vec3d)
+
+_Noise_B_ = _Freestyle._Noise_B_
+class Noise(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Noise, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Noise, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Noise(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Noise
+    __del__ = lambda self : None;
+    def turbulence1(*args): return _Freestyle.Noise_turbulence1(*args)
+    def turbulence2(*args): return _Freestyle.Noise_turbulence2(*args)
+    def turbulence3(*args): return _Freestyle.Noise_turbulence3(*args)
+    def smoothNoise1(*args): return _Freestyle.Noise_smoothNoise1(*args)
+    def smoothNoise2(*args): return _Freestyle.Noise_smoothNoise2(*args)
+    def smoothNoise3(*args): return _Freestyle.Noise_smoothNoise3(*args)
+Noise_swigregister = _Freestyle.Noise_swigregister
+Noise_swigregister(Noise)
+
+class Material(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Material, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Material, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Material(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Material
+    __del__ = lambda self : None;
+    def diffuse(*args): return _Freestyle.Material_diffuse(*args)
+    def diffuseR(*args): return _Freestyle.Material_diffuseR(*args)
+    def diffuseG(*args): return _Freestyle.Material_diffuseG(*args)
+    def diffuseB(*args): return _Freestyle.Material_diffuseB(*args)
+    def diffuseA(*args): return _Freestyle.Material_diffuseA(*args)
+    def specular(*args): return _Freestyle.Material_specular(*args)
+    def specularR(*args): return _Freestyle.Material_specularR(*args)
+    def specularG(*args): return _Freestyle.Material_specularG(*args)
+    def specularB(*args): return _Freestyle.Material_specularB(*args)
+    def specularA(*args): return _Freestyle.Material_specularA(*args)
+    def ambient(*args): return _Freestyle.Material_ambient(*args)
+    def ambientR(*args): return _Freestyle.Material_ambientR(*args)
+    def ambientG(*args): return _Freestyle.Material_ambientG(*args)
+    def ambientB(*args): return _Freestyle.Material_ambientB(*args)
+    def ambientA(*args): return _Freestyle.Material_ambientA(*args)
+    def emission(*args): return _Freestyle.Material_emission(*args)
+    def emissionR(*args): return _Freestyle.Material_emissionR(*args)
+    def emissionG(*args): return _Freestyle.Material_emissionG(*args)
+    def emissionB(*args): return _Freestyle.Material_emissionB(*args)
+    def emissionA(*args): return _Freestyle.Material_emissionA(*args)
+    def shininess(*args): return _Freestyle.Material_shininess(*args)
+    def setDiffuse(*args): return _Freestyle.Material_setDiffuse(*args)
+    def setSpecular(*args): return _Freestyle.Material_setSpecular(*args)
+    def setAmbient(*args): return _Freestyle.Material_setAmbient(*args)
+    def setEmission(*args): return _Freestyle.Material_setEmission(*args)
+    def setShininess(*args): return _Freestyle.Material_setShininess(*args)
+    def __ne__(*args): return _Freestyle.Material___ne__(*args)
+    def __eq__(*args): return _Freestyle.Material___eq__(*args)
+Material_swigregister = _Freestyle.Material_swigregister
+Material_swigregister(Material)
+
+class Interface0D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Interface0D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Interface0D, name)
+    __repr__ = _swig_repr
+    __swig_destroy__ = _Freestyle.delete_Interface0D
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.Interface0D_getExactTypeName(*args)
+    def getX(*args): return _Freestyle.Interface0D_getX(*args)
+    def getY(*args): return _Freestyle.Interface0D_getY(*args)
+    def getZ(*args): return _Freestyle.Interface0D_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.Interface0D_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.Interface0D_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.Interface0D_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.Interface0D_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.Interface0D_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.Interface0D_getFEdge(*args)
+    def getId(*args): return _Freestyle.Interface0D_getId(*args)
+    def getNature(*args): return _Freestyle.Interface0D_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.Interface0D_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.Interface0D_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.Interface0D_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.Interface0D_castToTVertex(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_Interface0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+Interface0D_swigregister = _Freestyle.Interface0D_swigregister
+Interface0D_swigregister(Interface0D)
+cvar = _Freestyle.cvar
+POINT = cvar.POINT
+S_VERTEX = cvar.S_VERTEX
+VIEW_VERTEX = cvar.VIEW_VERTEX
+NON_T_VERTEX = cvar.NON_T_VERTEX
+T_VERTEX = cvar.T_VERTEX
+CUSP = cvar.CUSP
+NO_FEATURE = cvar.NO_FEATURE
+SILHOUETTE = cvar.SILHOUETTE
+BORDER = cvar.BORDER
+CREASE = cvar.CREASE
+RIDGE = cvar.RIDGE
+VALLEY = cvar.VALLEY
+SUGGESTIVE_CONTOUR = cvar.SUGGESTIVE_CONTOUR
+
+class Interface0DIteratorNested(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Interface0DIteratorNested, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Interface0DIteratorNested, name)
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr
+    __swig_destroy__ = _Freestyle.delete_Interface0DIteratorNested
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.Interface0DIteratorNested_getExactTypeName(*args)
+    def getObject(*args): return _Freestyle.Interface0DIteratorNested_getObject(*args)
+    def __deref__(*args): return _Freestyle.Interface0DIteratorNested___deref__(*args)
+    def increment(*args): return _Freestyle.Interface0DIteratorNested_increment(*args)
+    def decrement(*args): return _Freestyle.Interface0DIteratorNested_decrement(*args)
+    def isBegin(*args): return _Freestyle.Interface0DIteratorNested_isBegin(*args)
+    def isEnd(*args): return _Freestyle.Interface0DIteratorNested_isEnd(*args)
+    def __eq__(*args): return _Freestyle.Interface0DIteratorNested___eq__(*args)
+    def __ne__(*args): return _Freestyle.Interface0DIteratorNested___ne__(*args)
+    def t(*args): return _Freestyle.Interface0DIteratorNested_t(*args)
+    def u(*args): return _Freestyle.Interface0DIteratorNested_u(*args)
+    def copy(*args): return _Freestyle.Interface0DIteratorNested_copy(*args)
+    def getX(*args): return _Freestyle.Interface0DIteratorNested_getX(*args)
+    def getY(*args): return _Freestyle.Interface0DIteratorNested_getY(*args)
+    def getZ(*args): return _Freestyle.Interface0DIteratorNested_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.Interface0DIteratorNested_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.Interface0DIteratorNested_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.Interface0DIteratorNested_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.Interface0DIteratorNested_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.Interface0DIteratorNested_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.Interface0DIteratorNested_getFEdge(*args)
+    def getId(*args): return _Freestyle.Interface0DIteratorNested_getId(*args)
+    def getNature(*args): return _Freestyle.Interface0DIteratorNested_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.Interface0DIteratorNested_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.Interface0DIteratorNested_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.Interface0DIteratorNested_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.Interface0DIteratorNested_castToTVertex(*args)
+Interface0DIteratorNested_swigregister = _Freestyle.Interface0DIteratorNested_swigregister
+Interface0DIteratorNested_swigregister(Interface0DIteratorNested)
+
+class Interface0DIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Interface0DIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Interface0DIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Interface0DIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Interface0DIterator
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.Interface0DIterator_getExactTypeName(*args)
+    def getObject(*args): return _Freestyle.Interface0DIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.Interface0DIterator___deref__(*args)
+    def increment(*args): return _Freestyle.Interface0DIterator_increment(*args)
+    def decrement(*args): return _Freestyle.Interface0DIterator_decrement(*args)
+    def isBegin(*args): return _Freestyle.Interface0DIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.Interface0DIterator_isEnd(*args)
+    def __eq__(*args): return _Freestyle.Interface0DIterator___eq__(*args)
+    def __ne__(*args): return _Freestyle.Interface0DIterator___ne__(*args)
+    def t(*args): return _Freestyle.Interface0DIterator_t(*args)
+    def u(*args): return _Freestyle.Interface0DIterator_u(*args)
+    def getX(*args): return _Freestyle.Interface0DIterator_getX(*args)
+    def getY(*args): return _Freestyle.Interface0DIterator_getY(*args)
+    def getZ(*args): return _Freestyle.Interface0DIterator_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.Interface0DIterator_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.Interface0DIterator_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.Interface0DIterator_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.Interface0DIterator_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.Interface0DIterator_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.Interface0DIterator_getFEdge(*args)
+    def getId(*args): return _Freestyle.Interface0DIterator_getId(*args)
+    def getNature(*args): return _Freestyle.Interface0DIterator_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.Interface0DIterator_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.Interface0DIterator_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.Interface0DIterator_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.Interface0DIterator_castToTVertex(*args)
+Interface0DIterator_swigregister = _Freestyle.Interface0DIterator_swigregister
+Interface0DIterator_swigregister(Interface0DIterator)
+
+MEAN = _Freestyle.MEAN
+MIN = _Freestyle.MIN
+MAX = _Freestyle.MAX
+FIRST = _Freestyle.FIRST
+LAST = _Freestyle.LAST
+class Interface1D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Interface1D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Interface1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Interface1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Interface1D
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.Interface1D_getExactTypeName(*args)
+    def verticesBegin(*args): return _Freestyle.Interface1D_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.Interface1D_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.Interface1D_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.Interface1D_pointsEnd(*args)
+    def getLength2D(*args): return _Freestyle.Interface1D_getLength2D(*args)
+    def getId(*args): return _Freestyle.Interface1D_getId(*args)
+    def getNature(*args): return _Freestyle.Interface1D_getNature(*args)
+    def getTimeStamp(*args): return _Freestyle.Interface1D_getTimeStamp(*args)
+    def setTimeStamp(*args): return _Freestyle.Interface1D_setTimeStamp(*args)
+Interface1D_swigregister = _Freestyle.Interface1D_swigregister
+Interface1D_swigregister(Interface1D)
+
+class SVertex(Interface0D):
+    __swig_setmethods__ = {}
+    for _s in [Interface0D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SVertex, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, SVertex, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.SVertex_getExactTypeName(*args)
+    def getX(*args): return _Freestyle.SVertex_getX(*args)
+    def getY(*args): return _Freestyle.SVertex_getY(*args)
+    def getZ(*args): return _Freestyle.SVertex_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.SVertex_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.SVertex_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.SVertex_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.SVertex_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.SVertex_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.SVertex_getFEdge(*args)
+    def getId(*args): return _Freestyle.SVertex_getId(*args)
+    def getNature(*args): return _Freestyle.SVertex_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.SVertex_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.SVertex_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.SVertex_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.SVertex_castToTVertex(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.SVertex_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.SVertex_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.SVertex_userdata_get, _Freestyle.SVertex_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_SVertex(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_SVertex
+    __del__ = lambda self : None;
+    def duplicate(*args): return _Freestyle.SVertex_duplicate(*args)
+    def __eq__(*args): return _Freestyle.SVertex___eq__(*args)
+    def point3D(*args): return _Freestyle.SVertex_point3D(*args)
+    def point2D(*args): return _Freestyle.SVertex_point2D(*args)
+    def normals(*args): return _Freestyle.SVertex_normals(*args)
+    def normalsSize(*args): return _Freestyle.SVertex_normalsSize(*args)
+    def fedges(*args): return _Freestyle.SVertex_fedges(*args)
+    def fedges_begin(*args): return _Freestyle.SVertex_fedges_begin(*args)
+    def fedges_end(*args): return _Freestyle.SVertex_fedges_end(*args)
+    def z(*args): return _Freestyle.SVertex_z(*args)
+    def viewvertex(*args): return _Freestyle.SVertex_viewvertex(*args)
+    def setPoint3D(*args): return _Freestyle.SVertex_setPoint3D(*args)
+    def setPoint2D(*args): return _Freestyle.SVertex_setPoint2D(*args)
+    def AddNormal(*args): return _Freestyle.SVertex_AddNormal(*args)
+    def setCurvatureInfo(*args): return _Freestyle.SVertex_setCurvatureInfo(*args)
+    def getCurvatureInfo(*args): return _Freestyle.SVertex_getCurvatureInfo(*args)
+    def setCurvatureFredo(*args): return _Freestyle.SVertex_setCurvatureFredo(*args)
+    def setDirectionFredo(*args): return _Freestyle.SVertex_setDirectionFredo(*args)
+    def curvatureFredo(*args): return _Freestyle.SVertex_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.SVertex_directionFredo(*args)
+    def setId(*args): return _Freestyle.SVertex_setId(*args)
+    def setFEdges(*args): return _Freestyle.SVertex_setFEdges(*args)
+    def setShape(*args): return _Freestyle.SVertex_setShape(*args)
+    def setViewVertex(*args): return _Freestyle.SVertex_setViewVertex(*args)
+    def AddFEdge(*args): return _Freestyle.SVertex_AddFEdge(*args)
+    def Replace(*args): return _Freestyle.SVertex_Replace(*args)
+    def fedge(*args): return _Freestyle.SVertex_fedge(*args)
+    def point2d(*args): return _Freestyle.SVertex_point2d(*args)
+    def point3d(*args): return _Freestyle.SVertex_point3d(*args)
+    def normal(*args): return _Freestyle.SVertex_normal(*args)
+    def shape_id(*args): return _Freestyle.SVertex_shape_id(*args)
+    def shape(*args): return _Freestyle.SVertex_shape(*args)
+    def shape_importance(*args): return _Freestyle.SVertex_shape_importance(*args)
+    def qi(*args): return _Freestyle.SVertex_qi(*args)
+    def occluders_begin(*args): return _Freestyle.SVertex_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.SVertex_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.SVertex_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.SVertex_occluders_size(*args)
+    def occludee(*args): return _Freestyle.SVertex_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.SVertex_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.SVertex_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.SVertex_z_discontinuity(*args)
+SVertex_swigregister = _Freestyle.SVertex_swigregister
+SVertex_swigregister(SVertex)
+integrateUnsigned = _Freestyle.integrateUnsigned
+integrateFloat = _Freestyle.integrateFloat
+integrateDouble = _Freestyle.integrateDouble
+
+class FEdge(Interface1D):
+    __swig_setmethods__ = {}
+    for _s in [Interface1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FEdge, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FEdge, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.FEdge_getExactTypeName(*args)
+    def getLength2D(*args): return _Freestyle.FEdge_getLength2D(*args)
+    def getId(*args): return _Freestyle.FEdge_getId(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.FEdge_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.FEdge_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.FEdge_userdata_get, _Freestyle.FEdge_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_FEdge(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_FEdge
+    __del__ = lambda self : None;
+    def duplicate(*args): return _Freestyle.FEdge_duplicate(*args)
+    def vertexA(*args): return _Freestyle.FEdge_vertexA(*args)
+    def vertexB(*args): return _Freestyle.FEdge_vertexB(*args)
+    def getNature(*args): return _Freestyle.FEdge_getNature(*args)
+    def nextEdge(*args): return _Freestyle.FEdge_nextEdge(*args)
+    def previousEdge(*args): return _Freestyle.FEdge_previousEdge(*args)
+    def invisibility(*args): return _Freestyle.FEdge_invisibility(*args)
+    def viewedge(*args): return _Freestyle.FEdge_viewedge(*args)
+    def center3d(*args): return _Freestyle.FEdge_center3d(*args)
+    def center2d(*args): return _Freestyle.FEdge_center2d(*args)
+    def aFace(*args): return _Freestyle.FEdge_aFace(*args)
+    def getOccludeeIntersection(*args): return _Freestyle.FEdge_getOccludeeIntersection(*args)
+    def getOccludeeEmpty(*args): return _Freestyle.FEdge_getOccludeeEmpty(*args)
+    def isSmooth(*args): return _Freestyle.FEdge_isSmooth(*args)
+    def setVertexA(*args): return _Freestyle.FEdge_setVertexA(*args)
+    def setVertexB(*args): return _Freestyle.FEdge_setVertexB(*args)
+    def setId(*args): return _Freestyle.FEdge_setId(*args)
+    def setNextEdge(*args): return _Freestyle.FEdge_setNextEdge(*args)
+    def setPreviousEdge(*args): return _Freestyle.FEdge_setPreviousEdge(*args)
+    def setNature(*args): return _Freestyle.FEdge_setNature(*args)
+    def setViewEdge(*args): return _Freestyle.FEdge_setViewEdge(*args)
+    def setaFace(*args): return _Freestyle.FEdge_setaFace(*args)
+    def setOccludeeIntersection(*args): return _Freestyle.FEdge_setOccludeeIntersection(*args)
+    def setOccludeeEmpty(*args): return _Freestyle.FEdge_setOccludeeEmpty(*args)
+    def setSmooth(*args): return _Freestyle.FEdge_setSmooth(*args)
+    __swig_getmethods__["CommonVertex"] = lambda x: _Freestyle.FEdge_CommonVertex
+    if _newclass:CommonVertex = staticmethod(_Freestyle.FEdge_CommonVertex)
+    def min2d(*args): return _Freestyle.FEdge_min2d(*args)
+    def max2d(*args): return _Freestyle.FEdge_max2d(*args)
+    def shape_id(*args): return _Freestyle.FEdge_shape_id(*args)
+    def shape(*args): return _Freestyle.FEdge_shape(*args)
+    def shape_importance(*args): return _Freestyle.FEdge_shape_importance(*args)
+    def qi(*args): return _Freestyle.FEdge_qi(*args)
+    def occluders_begin(*args): return _Freestyle.FEdge_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.FEdge_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.FEdge_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.FEdge_occluders_size(*args)
+    def occludee(*args): return _Freestyle.FEdge_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.FEdge_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.FEdge_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.FEdge_z_discontinuity(*args)
+    def viewedge_nature(*args): return _Freestyle.FEdge_viewedge_nature(*args)
+    def orientation2d(*args): return _Freestyle.FEdge_orientation2d(*args)
+    def orientation3d(*args): return _Freestyle.FEdge_orientation3d(*args)
+    def verticesBegin(*args): return _Freestyle.FEdge_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.FEdge_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.FEdge_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.FEdge_pointsEnd(*args)
+FEdge_swigregister = _Freestyle.FEdge_swigregister
+FEdge_swigregister(FEdge)
+FEdge_CommonVertex = _Freestyle.FEdge_CommonVertex
+
+class FEdgeSVertexIterator(Interface0DIteratorNested):
+    __swig_setmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FEdgeSVertexIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FEdgeSVertexIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_FEdgeSVertexIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getExactTypeName(*args): return _Freestyle.FEdgeSVertexIterator_getExactTypeName(*args)
+    def getObject(*args): return _Freestyle.FEdgeSVertexIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.FEdgeSVertexIterator___deref__(*args)
+    def increment(*args): return _Freestyle.FEdgeSVertexIterator_increment(*args)
+    def decrement(*args): return _Freestyle.FEdgeSVertexIterator_decrement(*args)
+    def isBegin(*args): return _Freestyle.FEdgeSVertexIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.FEdgeSVertexIterator_isEnd(*args)
+    def __eq__(*args): return _Freestyle.FEdgeSVertexIterator___eq__(*args)
+    def t(*args): return _Freestyle.FEdgeSVertexIterator_t(*args)
+    def u(*args): return _Freestyle.FEdgeSVertexIterator_u(*args)
+    def copy(*args): return _Freestyle.FEdgeSVertexIterator_copy(*args)
+    __swig_destroy__ = _Freestyle.delete_FEdgeSVertexIterator
+    __del__ = lambda self : None;
+    def getX(*args): return _Freestyle.FEdgeSVertexIterator_getX(*args)
+    def getY(*args): return _Freestyle.FEdgeSVertexIterator_getY(*args)
+    def getZ(*args): return _Freestyle.FEdgeSVertexIterator_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.FEdgeSVertexIterator_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.FEdgeSVertexIterator_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.FEdgeSVertexIterator_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.FEdgeSVertexIterator_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.FEdgeSVertexIterator_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.FEdgeSVertexIterator_getFEdge(*args)
+    def getId(*args): return _Freestyle.FEdgeSVertexIterator_getId(*args)
+    def getNature(*args): return _Freestyle.FEdgeSVertexIterator_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.FEdgeSVertexIterator_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.FEdgeSVertexIterator_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.FEdgeSVertexIterator_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.FEdgeSVertexIterator_castToTVertex(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.FEdgeSVertexIterator_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.FEdgeSVertexIterator_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.FEdgeSVertexIterator_userdata_get, _Freestyle.FEdgeSVertexIterator_userdata_set)
+    def duplicate(*args): return _Freestyle.FEdgeSVertexIterator_duplicate(*args)
+    def point3D(*args): return _Freestyle.FEdgeSVertexIterator_point3D(*args)
+    def point2D(*args): return _Freestyle.FEdgeSVertexIterator_point2D(*args)
+    def normals(*args): return _Freestyle.FEdgeSVertexIterator_normals(*args)
+    def normalsSize(*args): return _Freestyle.FEdgeSVertexIterator_normalsSize(*args)
+    def fedges(*args): return _Freestyle.FEdgeSVertexIterator_fedges(*args)
+    def fedges_begin(*args): return _Freestyle.FEdgeSVertexIterator_fedges_begin(*args)
+    def fedges_end(*args): return _Freestyle.FEdgeSVertexIterator_fedges_end(*args)
+    def shape(*args): return _Freestyle.FEdgeSVertexIterator_shape(*args)
+    def z(*args): return _Freestyle.FEdgeSVertexIterator_z(*args)
+    def viewvertex(*args): return _Freestyle.FEdgeSVertexIterator_viewvertex(*args)
+    def setPoint3D(*args): return _Freestyle.FEdgeSVertexIterator_setPoint3D(*args)
+    def setPoint2D(*args): return _Freestyle.FEdgeSVertexIterator_setPoint2D(*args)
+    def AddNormal(*args): return _Freestyle.FEdgeSVertexIterator_AddNormal(*args)
+    def setCurvatureInfo(*args): return _Freestyle.FEdgeSVertexIterator_setCurvatureInfo(*args)
+    def getCurvatureInfo(*args): return _Freestyle.FEdgeSVertexIterator_getCurvatureInfo(*args)
+    def setCurvatureFredo(*args): return _Freestyle.FEdgeSVertexIterator_setCurvatureFredo(*args)
+    def setDirectionFredo(*args): return _Freestyle.FEdgeSVertexIterator_setDirectionFredo(*args)
+    def curvatureFredo(*args): return _Freestyle.FEdgeSVertexIterator_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.FEdgeSVertexIterator_directionFredo(*args)
+    def setId(*args): return _Freestyle.FEdgeSVertexIterator_setId(*args)
+    def setFEdges(*args): return _Freestyle.FEdgeSVertexIterator_setFEdges(*args)
+    def setShape(*args): return _Freestyle.FEdgeSVertexIterator_setShape(*args)
+    def setViewVertex(*args): return _Freestyle.FEdgeSVertexIterator_setViewVertex(*args)
+    def AddFEdge(*args): return _Freestyle.FEdgeSVertexIterator_AddFEdge(*args)
+    def Replace(*args): return _Freestyle.FEdgeSVertexIterator_Replace(*args)
+    def fedge(*args): return _Freestyle.FEdgeSVertexIterator_fedge(*args)
+    def point2d(*args): return _Freestyle.FEdgeSVertexIterator_point2d(*args)
+    def point3d(*args): return _Freestyle.FEdgeSVertexIterator_point3d(*args)
+    def normal(*args): return _Freestyle.FEdgeSVertexIterator_normal(*args)
+    def shape_id(*args): return _Freestyle.FEdgeSVertexIterator_shape_id(*args)
+    def shape_importance(*args): return _Freestyle.FEdgeSVertexIterator_shape_importance(*args)
+    def qi(*args): return _Freestyle.FEdgeSVertexIterator_qi(*args)
+    def occluders_begin(*args): return _Freestyle.FEdgeSVertexIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.FEdgeSVertexIterator_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.FEdgeSVertexIterator_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.FEdgeSVertexIterator_occluders_size(*args)
+    def occludee(*args): return _Freestyle.FEdgeSVertexIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.FEdgeSVertexIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.FEdgeSVertexIterator_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.FEdgeSVertexIterator_z_discontinuity(*args)
+FEdgeSVertexIterator_swigregister = _Freestyle.FEdgeSVertexIterator_swigregister
+FEdgeSVertexIterator_swigregister(FEdgeSVertexIterator)
+
+class FEdgeSharp(FEdge):
+    __swig_setmethods__ = {}
+    for _s in [FEdge]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FEdgeSharp, name, value)
+    __swig_getmethods__ = {}
+    for _s in [FEdge]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FEdgeSharp, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_FEdgeSharp(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_FEdgeSharp
+    __del__ = lambda self : None;
+    def duplicate(*args): return _Freestyle.FEdgeSharp_duplicate(*args)
+    def normalA(*args): return _Freestyle.FEdgeSharp_normalA(*args)
+    def normalB(*args): return _Freestyle.FEdgeSharp_normalB(*args)
+    def aMaterialIndex(*args): return _Freestyle.FEdgeSharp_aMaterialIndex(*args)
+    def aMaterial(*args): return _Freestyle.FEdgeSharp_aMaterial(*args)
+    def bMaterialIndex(*args): return _Freestyle.FEdgeSharp_bMaterialIndex(*args)
+    def bMaterial(*args): return _Freestyle.FEdgeSharp_bMaterial(*args)
+    def setNormalA(*args): return _Freestyle.FEdgeSharp_setNormalA(*args)
+    def setNormalB(*args): return _Freestyle.FEdgeSharp_setNormalB(*args)
+    def setaMaterialIndex(*args): return _Freestyle.FEdgeSharp_setaMaterialIndex(*args)
+    def setbMaterialIndex(*args): return _Freestyle.FEdgeSharp_setbMaterialIndex(*args)
+FEdgeSharp_swigregister = _Freestyle.FEdgeSharp_swigregister
+FEdgeSharp_swigregister(FEdgeSharp)
+
+class FEdgeSmooth(FEdge):
+    __swig_setmethods__ = {}
+    for _s in [FEdge]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FEdgeSmooth, name, value)
+    __swig_getmethods__ = {}
+    for _s in [FEdge]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FEdgeSmooth, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_FEdgeSmooth(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_FEdgeSmooth
+    __del__ = lambda self : None;
+    def duplicate(*args): return _Freestyle.FEdgeSmooth_duplicate(*args)
+    def face(*args): return _Freestyle.FEdgeSmooth_face(*args)
+    def normal(*args): return _Freestyle.FEdgeSmooth_normal(*args)
+    def materialIndex(*args): return _Freestyle.FEdgeSmooth_materialIndex(*args)
+    def material(*args): return _Freestyle.FEdgeSmooth_material(*args)
+    def setFace(*args): return _Freestyle.FEdgeSmooth_setFace(*args)
+    def setNormal(*args): return _Freestyle.FEdgeSmooth_setNormal(*args)
+    def setMaterialIndex(*args): return _Freestyle.FEdgeSmooth_setMaterialIndex(*args)
+FEdgeSmooth_swigregister = _Freestyle.FEdgeSmooth_swigregister
+FEdgeSmooth_swigregister(FEdgeSmooth)
+
+class SShape(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SShape, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, SShape, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["userdata"] = _Freestyle.SShape_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.SShape_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.SShape_userdata_get, _Freestyle.SShape_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_SShape(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def duplicate(*args): return _Freestyle.SShape_duplicate(*args)
+    __swig_destroy__ = _Freestyle.delete_SShape
+    __del__ = lambda self : None;
+    def AddEdge(*args): return _Freestyle.SShape_AddEdge(*args)
+    def AddNewVertex(*args): return _Freestyle.SShape_AddNewVertex(*args)
+    def AddChain(*args): return _Freestyle.SShape_AddChain(*args)
+    def CreateSVertex(*args): return _Freestyle.SShape_CreateSVertex(*args)
+    def SplitEdge(*args): return _Freestyle.SShape_SplitEdge(*args)
+    def SplitEdgeIn2(*args): return _Freestyle.SShape_SplitEdgeIn2(*args)
+    def setBBox(*args): return _Freestyle.SShape_setBBox(*args)
+    def ComputeBBox(*args): return _Freestyle.SShape_ComputeBBox(*args)
+    def RemoveEdgeFromChain(*args): return _Freestyle.SShape_RemoveEdgeFromChain(*args)
+    def RemoveEdge(*args): return _Freestyle.SShape_RemoveEdge(*args)
+    def GetVertexList(*args): return _Freestyle.SShape_GetVertexList(*args)
+    def GetEdgeList(*args): return _Freestyle.SShape_GetEdgeList(*args)
+    def GetChains(*args): return _Freestyle.SShape_GetChains(*args)
+    def bbox(*args): return _Freestyle.SShape_bbox(*args)
+    def material(*args): return _Freestyle.SShape_material(*args)
+    def materials(*args): return _Freestyle.SShape_materials(*args)
+    def viewShape(*args): return _Freestyle.SShape_viewShape(*args)
+    def importance(*args): return _Freestyle.SShape_importance(*args)
+    def getId(*args): return _Freestyle.SShape_getId(*args)
+    def setId(*args): return _Freestyle.SShape_setId(*args)
+    def setMaterials(*args): return _Freestyle.SShape_setMaterials(*args)
+    def setViewShape(*args): return _Freestyle.SShape_setViewShape(*args)
+    def setImportance(*args): return _Freestyle.SShape_setImportance(*args)
+SShape_swigregister = _Freestyle.SShape_swigregister
+SShape_swigregister(SShape)
+
+class ViewShapesContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewShapesContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewShapesContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.ViewShapesContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.ViewShapesContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.ViewShapesContainer___len__(*args)
+    def pop(*args): return _Freestyle.ViewShapesContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.ViewShapesContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.ViewShapesContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.ViewShapesContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.ViewShapesContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.ViewShapesContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.ViewShapesContainer___setitem__(*args)
+    def append(*args): return _Freestyle.ViewShapesContainer_append(*args)
+    def empty(*args): return _Freestyle.ViewShapesContainer_empty(*args)
+    def size(*args): return _Freestyle.ViewShapesContainer_size(*args)
+    def clear(*args): return _Freestyle.ViewShapesContainer_clear(*args)
+    def swap(*args): return _Freestyle.ViewShapesContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.ViewShapesContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.ViewShapesContainer_begin(*args)
+    def end(*args): return _Freestyle.ViewShapesContainer_end(*args)
+    def rbegin(*args): return _Freestyle.ViewShapesContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.ViewShapesContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.ViewShapesContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.ViewShapesContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewShapesContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.ViewShapesContainer_push_back(*args)
+    def front(*args): return _Freestyle.ViewShapesContainer_front(*args)
+    def back(*args): return _Freestyle.ViewShapesContainer_back(*args)
+    def assign(*args): return _Freestyle.ViewShapesContainer_assign(*args)
+    def resize(*args): return _Freestyle.ViewShapesContainer_resize(*args)
+    def insert(*args): return _Freestyle.ViewShapesContainer_insert(*args)
+    def reserve(*args): return _Freestyle.ViewShapesContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.ViewShapesContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_ViewShapesContainer
+    __del__ = lambda self : None;
+ViewShapesContainer_swigregister = _Freestyle.ViewShapesContainer_swigregister
+ViewShapesContainer_swigregister(ViewShapesContainer)
+
+class ViewEdgesContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewEdgesContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewEdgesContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.ViewEdgesContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.ViewEdgesContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.ViewEdgesContainer___len__(*args)
+    def pop(*args): return _Freestyle.ViewEdgesContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.ViewEdgesContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.ViewEdgesContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.ViewEdgesContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.ViewEdgesContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.ViewEdgesContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.ViewEdgesContainer___setitem__(*args)
+    def append(*args): return _Freestyle.ViewEdgesContainer_append(*args)
+    def empty(*args): return _Freestyle.ViewEdgesContainer_empty(*args)
+    def size(*args): return _Freestyle.ViewEdgesContainer_size(*args)
+    def clear(*args): return _Freestyle.ViewEdgesContainer_clear(*args)
+    def swap(*args): return _Freestyle.ViewEdgesContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.ViewEdgesContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.ViewEdgesContainer_begin(*args)
+    def end(*args): return _Freestyle.ViewEdgesContainer_end(*args)
+    def rbegin(*args): return _Freestyle.ViewEdgesContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.ViewEdgesContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.ViewEdgesContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.ViewEdgesContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewEdgesContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.ViewEdgesContainer_push_back(*args)
+    def front(*args): return _Freestyle.ViewEdgesContainer_front(*args)
+    def back(*args): return _Freestyle.ViewEdgesContainer_back(*args)
+    def assign(*args): return _Freestyle.ViewEdgesContainer_assign(*args)
+    def resize(*args): return _Freestyle.ViewEdgesContainer_resize(*args)
+    def insert(*args): return _Freestyle.ViewEdgesContainer_insert(*args)
+    def reserve(*args): return _Freestyle.ViewEdgesContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.ViewEdgesContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_ViewEdgesContainer
+    __del__ = lambda self : None;
+ViewEdgesContainer_swigregister = _Freestyle.ViewEdgesContainer_swigregister
+ViewEdgesContainer_swigregister(ViewEdgesContainer)
+
+class FEdgesContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FEdgesContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, FEdgesContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.FEdgesContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.FEdgesContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.FEdgesContainer___len__(*args)
+    def pop(*args): return _Freestyle.FEdgesContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.FEdgesContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.FEdgesContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.FEdgesContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.FEdgesContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.FEdgesContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.FEdgesContainer___setitem__(*args)
+    def append(*args): return _Freestyle.FEdgesContainer_append(*args)
+    def empty(*args): return _Freestyle.FEdgesContainer_empty(*args)
+    def size(*args): return _Freestyle.FEdgesContainer_size(*args)
+    def clear(*args): return _Freestyle.FEdgesContainer_clear(*args)
+    def swap(*args): return _Freestyle.FEdgesContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.FEdgesContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.FEdgesContainer_begin(*args)
+    def end(*args): return _Freestyle.FEdgesContainer_end(*args)
+    def rbegin(*args): return _Freestyle.FEdgesContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.FEdgesContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.FEdgesContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.FEdgesContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_FEdgesContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.FEdgesContainer_push_back(*args)
+    def front(*args): return _Freestyle.FEdgesContainer_front(*args)
+    def back(*args): return _Freestyle.FEdgesContainer_back(*args)
+    def assign(*args): return _Freestyle.FEdgesContainer_assign(*args)
+    def resize(*args): return _Freestyle.FEdgesContainer_resize(*args)
+    def insert(*args): return _Freestyle.FEdgesContainer_insert(*args)
+    def reserve(*args): return _Freestyle.FEdgesContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.FEdgesContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_FEdgesContainer
+    __del__ = lambda self : None;
+FEdgesContainer_swigregister = _Freestyle.FEdgesContainer_swigregister
+FEdgesContainer_swigregister(FEdgesContainer)
+
+class ViewVerticesContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewVerticesContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewVerticesContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.ViewVerticesContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.ViewVerticesContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.ViewVerticesContainer___len__(*args)
+    def pop(*args): return _Freestyle.ViewVerticesContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.ViewVerticesContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.ViewVerticesContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.ViewVerticesContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.ViewVerticesContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.ViewVerticesContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.ViewVerticesContainer___setitem__(*args)
+    def append(*args): return _Freestyle.ViewVerticesContainer_append(*args)
+    def empty(*args): return _Freestyle.ViewVerticesContainer_empty(*args)
+    def size(*args): return _Freestyle.ViewVerticesContainer_size(*args)
+    def clear(*args): return _Freestyle.ViewVerticesContainer_clear(*args)
+    def swap(*args): return _Freestyle.ViewVerticesContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.ViewVerticesContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.ViewVerticesContainer_begin(*args)
+    def end(*args): return _Freestyle.ViewVerticesContainer_end(*args)
+    def rbegin(*args): return _Freestyle.ViewVerticesContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.ViewVerticesContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.ViewVerticesContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.ViewVerticesContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewVerticesContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.ViewVerticesContainer_push_back(*args)
+    def front(*args): return _Freestyle.ViewVerticesContainer_front(*args)
+    def back(*args): return _Freestyle.ViewVerticesContainer_back(*args)
+    def assign(*args): return _Freestyle.ViewVerticesContainer_assign(*args)
+    def resize(*args): return _Freestyle.ViewVerticesContainer_resize(*args)
+    def insert(*args): return _Freestyle.ViewVerticesContainer_insert(*args)
+    def reserve(*args): return _Freestyle.ViewVerticesContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.ViewVerticesContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_ViewVerticesContainer
+    __del__ = lambda self : None;
+ViewVerticesContainer_swigregister = _Freestyle.ViewVerticesContainer_swigregister
+ViewVerticesContainer_swigregister(ViewVerticesContainer)
+
+class SVerticesContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SVerticesContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, SVerticesContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.SVerticesContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.SVerticesContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.SVerticesContainer___len__(*args)
+    def pop(*args): return _Freestyle.SVerticesContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.SVerticesContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.SVerticesContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.SVerticesContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.SVerticesContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.SVerticesContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.SVerticesContainer___setitem__(*args)
+    def append(*args): return _Freestyle.SVerticesContainer_append(*args)
+    def empty(*args): return _Freestyle.SVerticesContainer_empty(*args)
+    def size(*args): return _Freestyle.SVerticesContainer_size(*args)
+    def clear(*args): return _Freestyle.SVerticesContainer_clear(*args)
+    def swap(*args): return _Freestyle.SVerticesContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.SVerticesContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.SVerticesContainer_begin(*args)
+    def end(*args): return _Freestyle.SVerticesContainer_end(*args)
+    def rbegin(*args): return _Freestyle.SVerticesContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.SVerticesContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.SVerticesContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.SVerticesContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_SVerticesContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.SVerticesContainer_push_back(*args)
+    def front(*args): return _Freestyle.SVerticesContainer_front(*args)
+    def back(*args): return _Freestyle.SVerticesContainer_back(*args)
+    def assign(*args): return _Freestyle.SVerticesContainer_assign(*args)
+    def resize(*args): return _Freestyle.SVerticesContainer_resize(*args)
+    def insert(*args): return _Freestyle.SVerticesContainer_insert(*args)
+    def reserve(*args): return _Freestyle.SVerticesContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.SVerticesContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_SVerticesContainer
+    __del__ = lambda self : None;
+SVerticesContainer_swigregister = _Freestyle.SVerticesContainer_swigregister
+SVerticesContainer_swigregister(SVerticesContainer)
+
+class ViewMap(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewMap, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewMap, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["userdata"] = _Freestyle.ViewMap_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewMap_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewMap_userdata_get, _Freestyle.ViewMap_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewMap(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ViewMap
+    __del__ = lambda self : None;
+    def GetClosestViewEdge(*args): return _Freestyle.ViewMap_GetClosestViewEdge(*args)
+    def GetClosestFEdge(*args): return _Freestyle.ViewMap_GetClosestFEdge(*args)
+    __swig_getmethods__["getInstance"] = lambda x: _Freestyle.ViewMap_getInstance
+    if _newclass:getInstance = staticmethod(_Freestyle.ViewMap_getInstance)
+    def ViewShapes(*args): return _Freestyle.ViewMap_ViewShapes(*args)
+    def ViewEdges(*args): return _Freestyle.ViewMap_ViewEdges(*args)
+    def ViewVertices(*args): return _Freestyle.ViewMap_ViewVertices(*args)
+    def FEdges(*args): return _Freestyle.ViewMap_FEdges(*args)
+    def SVertices(*args): return _Freestyle.ViewMap_SVertices(*args)
+    def viewedges_begin(*args): return _Freestyle.ViewMap_viewedges_begin(*args)
+    def viewedges_end(*args): return _Freestyle.ViewMap_viewedges_end(*args)
+    def viewedges_size(*args): return _Freestyle.ViewMap_viewedges_size(*args)
+    def viewShape(*args): return _Freestyle.ViewMap_viewShape(*args)
+    def shapeIdToIndexMap(*args): return _Freestyle.ViewMap_shapeIdToIndexMap(*args)
+    def getScene3dBBox(*args): return _Freestyle.ViewMap_getScene3dBBox(*args)
+    def AddViewShape(*args): return _Freestyle.ViewMap_AddViewShape(*args)
+    def AddViewEdge(*args): return _Freestyle.ViewMap_AddViewEdge(*args)
+    def AddViewVertex(*args): return _Freestyle.ViewMap_AddViewVertex(*args)
+    def AddFEdge(*args): return _Freestyle.ViewMap_AddFEdge(*args)
+    def AddSVertex(*args): return _Freestyle.ViewMap_AddSVertex(*args)
+    def setScene3dBBox(*args): return _Freestyle.ViewMap_setScene3dBBox(*args)
+    def CreateTVertex(*args): return _Freestyle.ViewMap_CreateTVertex(*args)
+    def InsertViewVertex(*args): return _Freestyle.ViewMap_InsertViewVertex(*args)
+ViewMap_swigregister = _Freestyle.ViewMap_swigregister
+ViewMap_swigregister(ViewMap)
+ViewMap_getInstance = _Freestyle.ViewMap_getInstance
+
+class ViewVertex(Interface0D):
+    __swig_setmethods__ = {}
+    for _s in [Interface0D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewVertex, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewVertex, name)
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.ViewVertex_getExactTypeName(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.ViewVertex_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewVertex_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewVertex_userdata_get, _Freestyle.ViewVertex_userdata_set)
+    __swig_destroy__ = _Freestyle.delete_ViewVertex
+    __del__ = lambda self : None;
+    def getNature(*args): return _Freestyle.ViewVertex_getNature(*args)
+    def setNature(*args): return _Freestyle.ViewVertex_setNature(*args)
+    def Replace(*args): return _Freestyle.ViewVertex_Replace(*args)
+    def edges_begin(*args): return _Freestyle.ViewVertex_edges_begin(*args)
+    def edges_end(*args): return _Freestyle.ViewVertex_edges_end(*args)
+    def edges_iterator(*args): return _Freestyle.ViewVertex_edges_iterator(*args)
+    def edgesBegin(*args): return _Freestyle.ViewVertex_edgesBegin(*args)
+    def edgesEnd(*args): return _Freestyle.ViewVertex_edgesEnd(*args)
+    def edgesIterator(*args): return _Freestyle.ViewVertex_edgesIterator(*args)
+ViewVertex_swigregister = _Freestyle.ViewVertex_swigregister
+ViewVertex_swigregister(ViewVertex)
+
+class TVertex(ViewVertex):
+    __swig_setmethods__ = {}
+    for _s in [ViewVertex]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TVertex, name, value)
+    __swig_getmethods__ = {}
+    for _s in [ViewVertex]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TVertex, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.TVertex_getExactTypeName(*args)
+    def getX(*args): return _Freestyle.TVertex_getX(*args)
+    def getY(*args): return _Freestyle.TVertex_getY(*args)
+    def getZ(*args): return _Freestyle.TVertex_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.TVertex_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.TVertex_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.TVertex_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.TVertex_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.TVertex_getPoint2D(*args)
+    def getId(*args): return _Freestyle.TVertex_getId(*args)
+    def castToViewVertex(*args): return _Freestyle.TVertex_castToViewVertex(*args)
+    def castToTVertex(*args): return _Freestyle.TVertex_castToTVertex(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_TVertex(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def frontSVertex(*args): return _Freestyle.TVertex_frontSVertex(*args)
+    def backSVertex(*args): return _Freestyle.TVertex_backSVertex(*args)
+    def frontEdgeA(*args): return _Freestyle.TVertex_frontEdgeA(*args)
+    def frontEdgeB(*args): return _Freestyle.TVertex_frontEdgeB(*args)
+    def backEdgeA(*args): return _Freestyle.TVertex_backEdgeA(*args)
+    def backEdgeB(*args): return _Freestyle.TVertex_backEdgeB(*args)
+    def setFrontVertex(*args): return _Freestyle.TVertex_setFrontVertex(*args)
+    def setBackSVertex(*args): return _Freestyle.TVertex_setBackSVertex(*args)
+    def setFrontEdgeA(*args): return _Freestyle.TVertex_setFrontEdgeA(*args)
+    def setFrontEdgeB(*args): return _Freestyle.TVertex_setFrontEdgeB(*args)
+    def setBackEdgeA(*args): return _Freestyle.TVertex_setBackEdgeA(*args)
+    def setBackEdgeB(*args): return _Freestyle.TVertex_setBackEdgeB(*args)
+    def setId(*args): return _Freestyle.TVertex_setId(*args)
+    def GetSVertex(*args): return _Freestyle.TVertex_GetSVertex(*args)
+    def Replace(*args): return _Freestyle.TVertex_Replace(*args)
+    def mate(*args): return _Freestyle.TVertex_mate(*args)
+    def edges_end(*args): return _Freestyle.TVertex_edges_end(*args)
+    def edgesBegin(*args): return _Freestyle.TVertex_edgesBegin(*args)
+    def edgesEnd(*args): return _Freestyle.TVertex_edgesEnd(*args)
+    def edgesIterator(*args): return _Freestyle.TVertex_edgesIterator(*args)
+    __swig_destroy__ = _Freestyle.delete_TVertex
+    __del__ = lambda self : None;
+TVertex_swigregister = _Freestyle.TVertex_swigregister
+TVertex_swigregister(TVertex)
+
+class NonTVertex(ViewVertex):
+    __swig_setmethods__ = {}
+    for _s in [ViewVertex]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, NonTVertex, name, value)
+    __swig_getmethods__ = {}
+    for _s in [ViewVertex]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, NonTVertex, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.NonTVertex_getExactTypeName(*args)
+    def getX(*args): return _Freestyle.NonTVertex_getX(*args)
+    def getY(*args): return _Freestyle.NonTVertex_getY(*args)
+    def getZ(*args): return _Freestyle.NonTVertex_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.NonTVertex_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.NonTVertex_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.NonTVertex_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.NonTVertex_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.NonTVertex_getPoint2D(*args)
+    def getId(*args): return _Freestyle.NonTVertex_getId(*args)
+    def castToSVertex(*args): return _Freestyle.NonTVertex_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.NonTVertex_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.NonTVertex_castToNonTVertex(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_NonTVertex(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_NonTVertex
+    __del__ = lambda self : None;
+    def svertex(*args): return _Freestyle.NonTVertex_svertex(*args)
+    def viewedges(*args): return _Freestyle.NonTVertex_viewedges(*args)
+    def setSVertex(*args): return _Freestyle.NonTVertex_setSVertex(*args)
+    def setViewEdges(*args): return _Freestyle.NonTVertex_setViewEdges(*args)
+    def AddIncomingViewEdge(*args): return _Freestyle.NonTVertex_AddIncomingViewEdge(*args)
+    def AddOutgoingViewEdge(*args): return _Freestyle.NonTVertex_AddOutgoingViewEdge(*args)
+    def AddViewEdge(*args): return _Freestyle.NonTVertex_AddViewEdge(*args)
+    def Replace(*args): return _Freestyle.NonTVertex_Replace(*args)
+    def edges_end(*args): return _Freestyle.NonTVertex_edges_end(*args)
+    def edgesBegin(*args): return _Freestyle.NonTVertex_edgesBegin(*args)
+    def edgesEnd(*args): return _Freestyle.NonTVertex_edgesEnd(*args)
+    def edgesIterator(*args): return _Freestyle.NonTVertex_edgesIterator(*args)
+NonTVertex_swigregister = _Freestyle.NonTVertex_swigregister
+NonTVertex_swigregister(NonTVertex)
+
+class ViewEdge(Interface1D):
+    __swig_setmethods__ = {}
+    for _s in [Interface1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewEdge, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewEdge, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.ViewEdge_getExactTypeName(*args)
+    def getId(*args): return _Freestyle.ViewEdge_getId(*args)
+    def getNature(*args): return _Freestyle.ViewEdge_getNature(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.ViewEdge_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewEdge_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewEdge_userdata_get, _Freestyle.ViewEdge_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewEdge(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ViewEdge
+    __del__ = lambda self : None;
+    def A(*args): return _Freestyle.ViewEdge_A(*args)
+    def B(*args): return _Freestyle.ViewEdge_B(*args)
+    def fedgeA(*args): return _Freestyle.ViewEdge_fedgeA(*args)
+    def fedgeB(*args): return _Freestyle.ViewEdge_fedgeB(*args)
+    def viewShape(*args): return _Freestyle.ViewEdge_viewShape(*args)
+    def isClosed(*args): return _Freestyle.ViewEdge_isClosed(*args)
+    def getChainingTimeStamp(*args): return _Freestyle.ViewEdge_getChainingTimeStamp(*args)
+    def aShape(*args): return _Freestyle.ViewEdge_aShape(*args)
+    def bShape(*args): return _Freestyle.ViewEdge_bShape(*args)
+    def occluders(*args): return _Freestyle.ViewEdge_occluders(*args)
+    def splittingId(*args): return _Freestyle.ViewEdge_splittingId(*args)
+    def setA(*args): return _Freestyle.ViewEdge_setA(*args)
+    def setB(*args): return _Freestyle.ViewEdge_setB(*args)
+    def setNature(*args): return _Freestyle.ViewEdge_setNature(*args)
+    def setFEdgeA(*args): return _Freestyle.ViewEdge_setFEdgeA(*args)
+    def setFEdgeB(*args): return _Freestyle.ViewEdge_setFEdgeB(*args)
+    def setShape(*args): return _Freestyle.ViewEdge_setShape(*args)
+    def setId(*args): return _Freestyle.ViewEdge_setId(*args)
+    def UpdateFEdges(*args): return _Freestyle.ViewEdge_UpdateFEdges(*args)
+    def setaShape(*args): return _Freestyle.ViewEdge_setaShape(*args)
+    def setQI(*args): return _Freestyle.ViewEdge_setQI(*args)
+    def setChainingTimeStamp(*args): return _Freestyle.ViewEdge_setChainingTimeStamp(*args)
+    def AddOccluder(*args): return _Freestyle.ViewEdge_AddOccluder(*args)
+    def setSplittingId(*args): return _Freestyle.ViewEdge_setSplittingId(*args)
+    def intersect_2d_area(*args): return _Freestyle.ViewEdge_intersect_2d_area(*args)
+    def include_in_2d_area(*args): return _Freestyle.ViewEdge_include_in_2d_area(*args)
+    def getLength2D(*args): return _Freestyle.ViewEdge_getLength2D(*args)
+    def qi(*args): return _Freestyle.ViewEdge_qi(*args)
+    def occluders_begin(*args): return _Freestyle.ViewEdge_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.ViewEdge_occluders_end(*args)
+    def occluders_size(*args): return _Freestyle.ViewEdge_occluders_size(*args)
+    def occluders_empty(*args): return _Freestyle.ViewEdge_occluders_empty(*args)
+    def occludee(*args): return _Freestyle.ViewEdge_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.ViewEdge_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.ViewEdge_occludee_empty(*args)
+    def shape_id(*args): return _Freestyle.ViewEdge_shape_id(*args)
+    def shape(*args): return _Freestyle.ViewEdge_shape(*args)
+    def shape_importance(*args): return _Freestyle.ViewEdge_shape_importance(*args)
+    def verticesBegin(*args): return _Freestyle.ViewEdge_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.ViewEdge_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.ViewEdge_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.ViewEdge_pointsEnd(*args)
+ViewEdge_swigregister = _Freestyle.ViewEdge_swigregister
+ViewEdge_swigregister(ViewEdge)
+
+class ViewShape(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewShape, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewShape, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["userdata"] = _Freestyle.ViewShape_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewShape_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewShape_userdata_get, _Freestyle.ViewShape_userdata_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewShape(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def duplicate(*args): return _Freestyle.ViewShape_duplicate(*args)
+    __swig_destroy__ = _Freestyle.delete_ViewShape
+    __del__ = lambda self : None;
+    def SplitEdge(*args): return _Freestyle.ViewShape_SplitEdge(*args)
+    def sshape(*args): return _Freestyle.ViewShape_sshape(*args)
+    def vertices(*args): return _Freestyle.ViewShape_vertices(*args)
+    def edges(*args): return _Freestyle.ViewShape_edges(*args)
+    def getId(*args): return _Freestyle.ViewShape_getId(*args)
+    def setSShape(*args): return _Freestyle.ViewShape_setSShape(*args)
+    def setVertices(*args): return _Freestyle.ViewShape_setVertices(*args)
+    def setEdges(*args): return _Freestyle.ViewShape_setEdges(*args)
+    def AddVertex(*args): return _Freestyle.ViewShape_AddVertex(*args)
+    def AddEdge(*args): return _Freestyle.ViewShape_AddEdge(*args)
+    def RemoveEdge(*args): return _Freestyle.ViewShape_RemoveEdge(*args)
+    def RemoveVertex(*args): return _Freestyle.ViewShape_RemoveVertex(*args)
+ViewShape_swigregister = _Freestyle.ViewShape_swigregister
+ViewShape_swigregister(ViewShape)
+
+class ViewVertexOrientedViewEdgeIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewVertexOrientedViewEdgeIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewVertexOrientedViewEdgeIterator, name)
+    __repr__ = _swig_repr
+    __swig_destroy__ = _Freestyle.delete_ViewVertexOrientedViewEdgeIterator
+    __del__ = lambda self : None;
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewVertexOrientedViewEdgeIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def isBegin(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator_isEnd(*args)
+    def __ne__(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator___ne__(*args)
+    def __eq__(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator___eq__(*args)
+    def getObject(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator___deref__(*args)
+    def increment(*args): return _Freestyle.ViewVertexOrientedViewEdgeIterator_increment(*args)
+ViewVertexOrientedViewEdgeIterator_swigregister = _Freestyle.ViewVertexOrientedViewEdgeIterator_swigregister
+ViewVertexOrientedViewEdgeIterator_swigregister(ViewVertexOrientedViewEdgeIterator)
+
+class ViewEdgeSVertexIterator(Interface0DIteratorNested):
+    __swig_setmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewEdgeSVertexIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewEdgeSVertexIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewEdgeSVertexIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ViewEdgeSVertexIterator
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.ViewEdgeSVertexIterator_getExactTypeName(*args)
+    def getObject(*args): return _Freestyle.ViewEdgeSVertexIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.ViewEdgeSVertexIterator___deref__(*args)
+    def increment(*args): return _Freestyle.ViewEdgeSVertexIterator_increment(*args)
+    def decrement(*args): return _Freestyle.ViewEdgeSVertexIterator_decrement(*args)
+    def isBegin(*args): return _Freestyle.ViewEdgeSVertexIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.ViewEdgeSVertexIterator_isEnd(*args)
+    def t(*args): return _Freestyle.ViewEdgeSVertexIterator_t(*args)
+    def u(*args): return _Freestyle.ViewEdgeSVertexIterator_u(*args)
+    def __eq__(*args): return _Freestyle.ViewEdgeSVertexIterator___eq__(*args)
+    def copy(*args): return _Freestyle.ViewEdgeSVertexIterator_copy(*args)
+    def getX(*args): return _Freestyle.ViewEdgeSVertexIterator_getX(*args)
+    def getY(*args): return _Freestyle.ViewEdgeSVertexIterator_getY(*args)
+    def getZ(*args): return _Freestyle.ViewEdgeSVertexIterator_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.ViewEdgeSVertexIterator_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.ViewEdgeSVertexIterator_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.ViewEdgeSVertexIterator_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.ViewEdgeSVertexIterator_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.ViewEdgeSVertexIterator_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.ViewEdgeSVertexIterator_getFEdge(*args)
+    def getId(*args): return _Freestyle.ViewEdgeSVertexIterator_getId(*args)
+    def getNature(*args): return _Freestyle.ViewEdgeSVertexIterator_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.ViewEdgeSVertexIterator_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.ViewEdgeSVertexIterator_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.ViewEdgeSVertexIterator_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.ViewEdgeSVertexIterator_castToTVertex(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.ViewEdgeSVertexIterator_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewEdgeSVertexIterator_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewEdgeSVertexIterator_userdata_get, _Freestyle.ViewEdgeSVertexIterator_userdata_set)
+    def duplicate(*args): return _Freestyle.ViewEdgeSVertexIterator_duplicate(*args)
+    def point3D(*args): return _Freestyle.ViewEdgeSVertexIterator_point3D(*args)
+    def point2D(*args): return _Freestyle.ViewEdgeSVertexIterator_point2D(*args)
+    def normals(*args): return _Freestyle.ViewEdgeSVertexIterator_normals(*args)
+    def normalsSize(*args): return _Freestyle.ViewEdgeSVertexIterator_normalsSize(*args)
+    def fedges(*args): return _Freestyle.ViewEdgeSVertexIterator_fedges(*args)
+    def fedges_begin(*args): return _Freestyle.ViewEdgeSVertexIterator_fedges_begin(*args)
+    def fedges_end(*args): return _Freestyle.ViewEdgeSVertexIterator_fedges_end(*args)
+    def shape(*args): return _Freestyle.ViewEdgeSVertexIterator_shape(*args)
+    def z(*args): return _Freestyle.ViewEdgeSVertexIterator_z(*args)
+    def viewvertex(*args): return _Freestyle.ViewEdgeSVertexIterator_viewvertex(*args)
+    def setPoint3D(*args): return _Freestyle.ViewEdgeSVertexIterator_setPoint3D(*args)
+    def setPoint2D(*args): return _Freestyle.ViewEdgeSVertexIterator_setPoint2D(*args)
+    def AddNormal(*args): return _Freestyle.ViewEdgeSVertexIterator_AddNormal(*args)
+    def setCurvatureInfo(*args): return _Freestyle.ViewEdgeSVertexIterator_setCurvatureInfo(*args)
+    def getCurvatureInfo(*args): return _Freestyle.ViewEdgeSVertexIterator_getCurvatureInfo(*args)
+    def setCurvatureFredo(*args): return _Freestyle.ViewEdgeSVertexIterator_setCurvatureFredo(*args)
+    def setDirectionFredo(*args): return _Freestyle.ViewEdgeSVertexIterator_setDirectionFredo(*args)
+    def curvatureFredo(*args): return _Freestyle.ViewEdgeSVertexIterator_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.ViewEdgeSVertexIterator_directionFredo(*args)
+    def setId(*args): return _Freestyle.ViewEdgeSVertexIterator_setId(*args)
+    def setFEdges(*args): return _Freestyle.ViewEdgeSVertexIterator_setFEdges(*args)
+    def setShape(*args): return _Freestyle.ViewEdgeSVertexIterator_setShape(*args)
+    def setViewVertex(*args): return _Freestyle.ViewEdgeSVertexIterator_setViewVertex(*args)
+    def AddFEdge(*args): return _Freestyle.ViewEdgeSVertexIterator_AddFEdge(*args)
+    def Replace(*args): return _Freestyle.ViewEdgeSVertexIterator_Replace(*args)
+    def fedge(*args): return _Freestyle.ViewEdgeSVertexIterator_fedge(*args)
+    def point2d(*args): return _Freestyle.ViewEdgeSVertexIterator_point2d(*args)
+    def point3d(*args): return _Freestyle.ViewEdgeSVertexIterator_point3d(*args)
+    def normal(*args): return _Freestyle.ViewEdgeSVertexIterator_normal(*args)
+    def shape_id(*args): return _Freestyle.ViewEdgeSVertexIterator_shape_id(*args)
+    def shape_importance(*args): return _Freestyle.ViewEdgeSVertexIterator_shape_importance(*args)
+    def qi(*args): return _Freestyle.ViewEdgeSVertexIterator_qi(*args)
+    def occluders_begin(*args): return _Freestyle.ViewEdgeSVertexIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.ViewEdgeSVertexIterator_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.ViewEdgeSVertexIterator_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.ViewEdgeSVertexIterator_occluders_size(*args)
+    def occludee(*args): return _Freestyle.ViewEdgeSVertexIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.ViewEdgeSVertexIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.ViewEdgeSVertexIterator_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.ViewEdgeSVertexIterator_z_discontinuity(*args)
+ViewEdgeSVertexIterator_swigregister = _Freestyle.ViewEdgeSVertexIterator_swigregister
+ViewEdgeSVertexIterator_swigregister(ViewEdgeSVertexIterator)
+
+class ViewEdgeViewEdgeIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewEdgeViewEdgeIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewEdgeViewEdgeIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == ViewEdgeViewEdgeIterator:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_ViewEdgeViewEdgeIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ViewEdgeViewEdgeIterator
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getExactTypeName(*args)
+    def getCurrentEdge(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getCurrentEdge(*args)
+    def setCurrentEdge(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setCurrentEdge(*args)
+    def getBegin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getBegin(*args)
+    def setBegin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setBegin(*args)
+    def getOrientation(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getOrientation(*args)
+    def setOrientation(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setOrientation(*args)
+    def changeOrientation(*args): return _Freestyle.ViewEdgeViewEdgeIterator_changeOrientation(*args)
+    def getObject(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.ViewEdgeViewEdgeIterator___deref__(*args)
+    def increment(*args): return _Freestyle.ViewEdgeViewEdgeIterator_increment(*args)
+    def decrement(*args): return _Freestyle.ViewEdgeViewEdgeIterator_decrement(*args)
+    def isBegin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.ViewEdgeViewEdgeIterator_isEnd(*args)
+    def __eq__(*args): return _Freestyle.ViewEdgeViewEdgeIterator___eq__(*args)
+    def __ne__(*args): return _Freestyle.ViewEdgeViewEdgeIterator___ne__(*args)
+    def getId(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getId(*args)
+    def getNature(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getNature(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.ViewEdgeViewEdgeIterator_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.ViewEdgeViewEdgeIterator_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.ViewEdgeViewEdgeIterator_userdata_get, _Freestyle.ViewEdgeViewEdgeIterator_userdata_set)
+    def A(*args): return _Freestyle.ViewEdgeViewEdgeIterator_A(*args)
+    def B(*args): return _Freestyle.ViewEdgeViewEdgeIterator_B(*args)
+    def fedgeA(*args): return _Freestyle.ViewEdgeViewEdgeIterator_fedgeA(*args)
+    def fedgeB(*args): return _Freestyle.ViewEdgeViewEdgeIterator_fedgeB(*args)
+    def viewShape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_viewShape(*args)
+    def aShape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_aShape(*args)
+    def isClosed(*args): return _Freestyle.ViewEdgeViewEdgeIterator_isClosed(*args)
+    def getChainingTimeStamp(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getChainingTimeStamp(*args)
+    def bShape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_bShape(*args)
+    def occluders(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluders(*args)
+    def splittingId(*args): return _Freestyle.ViewEdgeViewEdgeIterator_splittingId(*args)
+    def setA(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setA(*args)
+    def setB(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setB(*args)
+    def setNature(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setNature(*args)
+    def setFEdgeA(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setFEdgeA(*args)
+    def setFEdgeB(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setFEdgeB(*args)
+    def setShape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setShape(*args)
+    def setId(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setId(*args)
+    def UpdateFEdges(*args): return _Freestyle.ViewEdgeViewEdgeIterator_UpdateFEdges(*args)
+    def setaShape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setaShape(*args)
+    def setQI(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setQI(*args)
+    def setChainingTimeStamp(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setChainingTimeStamp(*args)
+    def AddOccluder(*args): return _Freestyle.ViewEdgeViewEdgeIterator_AddOccluder(*args)
+    def setSplittingId(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setSplittingId(*args)
+    def intersect_2d_area(*args): return _Freestyle.ViewEdgeViewEdgeIterator_intersect_2d_area(*args)
+    def include_in_2d_area(*args): return _Freestyle.ViewEdgeViewEdgeIterator_include_in_2d_area(*args)
+    def getLength2D(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getLength2D(*args)
+    def qi(*args): return _Freestyle.ViewEdgeViewEdgeIterator_qi(*args)
+    def occluders_begin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluders_end(*args)
+    def occluders_size(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluders_size(*args)
+    def occluders_empty(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluders_empty(*args)
+    def occludee(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.ViewEdgeViewEdgeIterator_occludee_empty(*args)
+    def shape_id(*args): return _Freestyle.ViewEdgeViewEdgeIterator_shape_id(*args)
+    def shape(*args): return _Freestyle.ViewEdgeViewEdgeIterator_shape(*args)
+    def shape_importance(*args): return _Freestyle.ViewEdgeViewEdgeIterator_shape_importance(*args)
+    def verticesBegin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.ViewEdgeViewEdgeIterator_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.ViewEdgeViewEdgeIterator_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.ViewEdgeViewEdgeIterator_pointsEnd(*args)
+    def getTimeStamp(*args): return _Freestyle.ViewEdgeViewEdgeIterator_getTimeStamp(*args)
+    def setTimeStamp(*args): return _Freestyle.ViewEdgeViewEdgeIterator_setTimeStamp(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_ViewEdgeViewEdgeIterator(self)
+        return weakref_proxy(self)
+ViewEdgeViewEdgeIterator_swigregister = _Freestyle.ViewEdgeViewEdgeIterator_swigregister
+ViewEdgeViewEdgeIterator_swigregister(ViewEdgeViewEdgeIterator)
+
+class UnaryFunction0DVoid(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DVoid, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DVoid, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DVoid:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DVoid(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DVoid
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DVoid_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DVoid___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DVoid(self)
+        return weakref_proxy(self)
+UnaryFunction0DVoid_swigregister = _Freestyle.UnaryFunction0DVoid_swigregister
+UnaryFunction0DVoid_swigregister(UnaryFunction0DVoid)
+
+class UnaryFunction0DUnsigned(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DUnsigned, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DUnsigned, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DUnsigned:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DUnsigned(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DUnsigned
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DUnsigned_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DUnsigned___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DUnsigned(self)
+        return weakref_proxy(self)
+UnaryFunction0DUnsigned_swigregister = _Freestyle.UnaryFunction0DUnsigned_swigregister
+UnaryFunction0DUnsigned_swigregister(UnaryFunction0DUnsigned)
+
+class UnaryFunction0DFloat(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DFloat, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DFloat, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DFloat:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DFloat(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DFloat
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DFloat_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DFloat___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DFloat(self)
+        return weakref_proxy(self)
+UnaryFunction0DFloat_swigregister = _Freestyle.UnaryFunction0DFloat_swigregister
+UnaryFunction0DFloat_swigregister(UnaryFunction0DFloat)
+
+class UnaryFunction0DDouble(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DDouble, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DDouble, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DDouble:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DDouble(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DDouble
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DDouble_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DDouble___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DDouble(self)
+        return weakref_proxy(self)
+UnaryFunction0DDouble_swigregister = _Freestyle.UnaryFunction0DDouble_swigregister
+UnaryFunction0DDouble_swigregister(UnaryFunction0DDouble)
+
+class UnaryFunction0DVec2f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DVec2f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DVec2f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DVec2f:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DVec2f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DVec2f
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DVec2f_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DVec2f___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DVec2f(self)
+        return weakref_proxy(self)
+UnaryFunction0DVec2f_swigregister = _Freestyle.UnaryFunction0DVec2f_swigregister
+UnaryFunction0DVec2f_swigregister(UnaryFunction0DVec2f)
+
+class UnaryFunction0DVec3f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DVec3f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DVec3f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DVec3f:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DVec3f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DVec3f
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DVec3f_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DVec3f___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DVec3f(self)
+        return weakref_proxy(self)
+UnaryFunction0DVec3f_swigregister = _Freestyle.UnaryFunction0DVec3f_swigregister
+UnaryFunction0DVec3f_swigregister(UnaryFunction0DVec3f)
+
+class UnaryFunction0DId(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DId, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DId, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction0DId:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction0DId(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DId
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DId_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DId___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction0DId(self)
+        return weakref_proxy(self)
+UnaryFunction0DId_swigregister = _Freestyle.UnaryFunction0DId_swigregister
+UnaryFunction0DId_swigregister(UnaryFunction0DId)
+
+class UnaryFunction0DViewShape(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DViewShape, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DViewShape, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_UnaryFunction0DViewShape(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DViewShape
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DViewShape_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DViewShape___call__(*args)
+UnaryFunction0DViewShape_swigregister = _Freestyle.UnaryFunction0DViewShape_swigregister
+UnaryFunction0DViewShape_swigregister(UnaryFunction0DViewShape)
+
+class UnaryFunction0DVectorViewShape(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction0DVectorViewShape, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction0DVectorViewShape, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_UnaryFunction0DVectorViewShape(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction0DVectorViewShape
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction0DVectorViewShape_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction0DVectorViewShape___call__(*args)
+UnaryFunction0DVectorViewShape_swigregister = _Freestyle.UnaryFunction0DVectorViewShape_swigregister
+UnaryFunction0DVectorViewShape_swigregister(UnaryFunction0DVectorViewShape)
+
+class GetXF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetXF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetXF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetXF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetXF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetXF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetXF0D
+    __del__ = lambda self : None;
+GetXF0D_swigregister = _Freestyle.GetXF0D_swigregister
+GetXF0D_swigregister(GetXF0D)
+
+class GetYF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetYF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetYF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetYF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetYF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetYF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetYF0D
+    __del__ = lambda self : None;
+GetYF0D_swigregister = _Freestyle.GetYF0D_swigregister
+GetYF0D_swigregister(GetYF0D)
+
+class GetZF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetZF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetZF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetZF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetZF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetZF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetZF0D
+    __del__ = lambda self : None;
+GetZF0D_swigregister = _Freestyle.GetZF0D_swigregister
+GetZF0D_swigregister(GetZF0D)
+
+class GetProjectedXF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedXF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedXF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetProjectedXF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedXF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedXF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetProjectedXF0D
+    __del__ = lambda self : None;
+GetProjectedXF0D_swigregister = _Freestyle.GetProjectedXF0D_swigregister
+GetProjectedXF0D_swigregister(GetProjectedXF0D)
+
+class GetProjectedYF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedYF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedYF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetProjectedYF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedYF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedYF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetProjectedYF0D
+    __del__ = lambda self : None;
+GetProjectedYF0D_swigregister = _Freestyle.GetProjectedYF0D_swigregister
+GetProjectedYF0D_swigregister(GetProjectedYF0D)
+
+class GetProjectedZF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedZF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedZF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetProjectedZF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedZF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedZF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetProjectedZF0D
+    __del__ = lambda self : None;
+GetProjectedZF0D_swigregister = _Freestyle.GetProjectedZF0D_swigregister
+GetProjectedZF0D_swigregister(GetProjectedZF0D)
+
+class GetCurvilinearAbscissaF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetCurvilinearAbscissaF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetCurvilinearAbscissaF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetCurvilinearAbscissaF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetCurvilinearAbscissaF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetCurvilinearAbscissaF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetCurvilinearAbscissaF0D
+    __del__ = lambda self : None;
+GetCurvilinearAbscissaF0D_swigregister = _Freestyle.GetCurvilinearAbscissaF0D_swigregister
+GetCurvilinearAbscissaF0D_swigregister(GetCurvilinearAbscissaF0D)
+
+class GetParameterF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetParameterF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetParameterF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetParameterF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetParameterF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetParameterF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetParameterF0D
+    __del__ = lambda self : None;
+GetParameterF0D_swigregister = _Freestyle.GetParameterF0D_swigregister
+GetParameterF0D_swigregister(GetParameterF0D)
+
+class VertexOrientation2DF0D(UnaryFunction0DVec2f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DVec2f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, VertexOrientation2DF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DVec2f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, VertexOrientation2DF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.VertexOrientation2DF0D_getName(*args)
+    def __call__(*args): return _Freestyle.VertexOrientation2DF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_VertexOrientation2DF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_VertexOrientation2DF0D
+    __del__ = lambda self : None;
+VertexOrientation2DF0D_swigregister = _Freestyle.VertexOrientation2DF0D_swigregister
+VertexOrientation2DF0D_swigregister(VertexOrientation2DF0D)
+
+class VertexOrientation3DF0D(UnaryFunction0DVec3f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DVec3f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, VertexOrientation3DF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DVec3f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, VertexOrientation3DF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.VertexOrientation3DF0D_getName(*args)
+    def __call__(*args): return _Freestyle.VertexOrientation3DF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_VertexOrientation3DF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_VertexOrientation3DF0D
+    __del__ = lambda self : None;
+VertexOrientation3DF0D_swigregister = _Freestyle.VertexOrientation3DF0D_swigregister
+VertexOrientation3DF0D_swigregister(VertexOrientation3DF0D)
+
+class Curvature2DAngleF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Curvature2DAngleF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Curvature2DAngleF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.Curvature2DAngleF0D_getName(*args)
+    def __call__(*args): return _Freestyle.Curvature2DAngleF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_Curvature2DAngleF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Curvature2DAngleF0D
+    __del__ = lambda self : None;
+Curvature2DAngleF0D_swigregister = _Freestyle.Curvature2DAngleF0D_swigregister
+Curvature2DAngleF0D_swigregister(Curvature2DAngleF0D)
+
+class ZDiscontinuityF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ZDiscontinuityF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ZDiscontinuityF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.ZDiscontinuityF0D_getName(*args)
+    def __call__(*args): return _Freestyle.ZDiscontinuityF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ZDiscontinuityF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ZDiscontinuityF0D
+    __del__ = lambda self : None;
+ZDiscontinuityF0D_swigregister = _Freestyle.ZDiscontinuityF0D_swigregister
+ZDiscontinuityF0D_swigregister(ZDiscontinuityF0D)
+
+class Normal2DF0D(UnaryFunction0DVec2f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DVec2f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Normal2DF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DVec2f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Normal2DF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.Normal2DF0D_getName(*args)
+    def __call__(*args): return _Freestyle.Normal2DF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_Normal2DF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Normal2DF0D
+    __del__ = lambda self : None;
+Normal2DF0D_swigregister = _Freestyle.Normal2DF0D_swigregister
+Normal2DF0D_swigregister(Normal2DF0D)
+
+class MaterialF0D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, MaterialF0D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, MaterialF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.MaterialF0D_getName(*args)
+    def __call__(*args): return _Freestyle.MaterialF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_MaterialF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_MaterialF0D
+    __del__ = lambda self : None;
+MaterialF0D_swigregister = _Freestyle.MaterialF0D_swigregister
+MaterialF0D_swigregister(MaterialF0D)
+
+class ShapeIdF0D(UnaryFunction0DId):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DId]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ShapeIdF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DId]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ShapeIdF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.ShapeIdF0D_getName(*args)
+    def __call__(*args): return _Freestyle.ShapeIdF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ShapeIdF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ShapeIdF0D
+    __del__ = lambda self : None;
+ShapeIdF0D_swigregister = _Freestyle.ShapeIdF0D_swigregister
+ShapeIdF0D_swigregister(ShapeIdF0D)
+
+class QuantitativeInvisibilityF0D(UnaryFunction0DUnsigned):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DUnsigned]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, QuantitativeInvisibilityF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DUnsigned]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, QuantitativeInvisibilityF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.QuantitativeInvisibilityF0D_getName(*args)
+    def __call__(*args): return _Freestyle.QuantitativeInvisibilityF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_QuantitativeInvisibilityF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_QuantitativeInvisibilityF0D
+    __del__ = lambda self : None;
+QuantitativeInvisibilityF0D_swigregister = _Freestyle.QuantitativeInvisibilityF0D_swigregister
+QuantitativeInvisibilityF0D_swigregister(QuantitativeInvisibilityF0D)
+
+class CurveNatureF0D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CurveNatureF0D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, CurveNatureF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.CurveNatureF0D_getName(*args)
+    def __call__(*args): return _Freestyle.CurveNatureF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_CurveNatureF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_CurveNatureF0D
+    __del__ = lambda self : None;
+CurveNatureF0D_swigregister = _Freestyle.CurveNatureF0D_swigregister
+CurveNatureF0D_swigregister(CurveNatureF0D)
+
+class GetShapeF0D(UnaryFunction0DViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetShapeF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetShapeF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetShapeF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetShapeF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetShapeF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetShapeF0D
+    __del__ = lambda self : None;
+GetShapeF0D_swigregister = _Freestyle.GetShapeF0D_swigregister
+GetShapeF0D_swigregister(GetShapeF0D)
+
+class GetOccludersF0D(UnaryFunction0DVectorViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DVectorViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetOccludersF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DVectorViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetOccludersF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetOccludersF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetOccludersF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetOccludersF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetOccludersF0D
+    __del__ = lambda self : None;
+GetOccludersF0D_swigregister = _Freestyle.GetOccludersF0D_swigregister
+GetOccludersF0D_swigregister(GetOccludersF0D)
+
+class GetOccludeeF0D(UnaryFunction0DViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetOccludeeF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetOccludeeF0D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.GetOccludeeF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetOccludeeF0D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetOccludeeF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetOccludeeF0D
+    __del__ = lambda self : None;
+GetOccludeeF0D_swigregister = _Freestyle.GetOccludeeF0D_swigregister
+GetOccludeeF0D_swigregister(GetOccludeeF0D)
+
+getFEdge = _Freestyle.getFEdge
+class UnaryFunction1DVoid(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DVoid, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DVoid, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DVoid:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DVoid(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DVoid
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DVoid_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DVoid___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DVoid_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DVoid_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DVoid(self)
+        return weakref_proxy(self)
+UnaryFunction1DVoid_swigregister = _Freestyle.UnaryFunction1DVoid_swigregister
+UnaryFunction1DVoid_swigregister(UnaryFunction1DVoid)
+
+class UnaryFunction1DUnsigned(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DUnsigned, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DUnsigned, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DUnsigned:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DUnsigned(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DUnsigned
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DUnsigned_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DUnsigned___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DUnsigned_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DUnsigned_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DUnsigned(self)
+        return weakref_proxy(self)
+UnaryFunction1DUnsigned_swigregister = _Freestyle.UnaryFunction1DUnsigned_swigregister
+UnaryFunction1DUnsigned_swigregister(UnaryFunction1DUnsigned)
+
+class UnaryFunction1DFloat(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DFloat, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DFloat, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DFloat:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DFloat(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DFloat
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DFloat_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DFloat___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DFloat_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DFloat_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DFloat(self)
+        return weakref_proxy(self)
+UnaryFunction1DFloat_swigregister = _Freestyle.UnaryFunction1DFloat_swigregister
+UnaryFunction1DFloat_swigregister(UnaryFunction1DFloat)
+
+class UnaryFunction1DDouble(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DDouble, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DDouble, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DDouble:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DDouble(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DDouble
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DDouble_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DDouble___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DDouble_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DDouble_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DDouble(self)
+        return weakref_proxy(self)
+UnaryFunction1DDouble_swigregister = _Freestyle.UnaryFunction1DDouble_swigregister
+UnaryFunction1DDouble_swigregister(UnaryFunction1DDouble)
+
+class UnaryFunction1DVec2f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DVec2f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DVec2f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DVec2f:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DVec2f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DVec2f
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DVec2f_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DVec2f___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DVec2f_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DVec2f_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DVec2f(self)
+        return weakref_proxy(self)
+UnaryFunction1DVec2f_swigregister = _Freestyle.UnaryFunction1DVec2f_swigregister
+UnaryFunction1DVec2f_swigregister(UnaryFunction1DVec2f)
+
+class UnaryFunction1DVec3f(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DVec3f, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DVec3f, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryFunction1DVec3f:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryFunction1DVec3f(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DVec3f
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DVec3f_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DVec3f___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DVec3f_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DVec3f_getIntegrationType(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryFunction1DVec3f(self)
+        return weakref_proxy(self)
+UnaryFunction1DVec3f_swigregister = _Freestyle.UnaryFunction1DVec3f_swigregister
+UnaryFunction1DVec3f_swigregister(UnaryFunction1DVec3f)
+
+class UnaryFunction1DVectorViewShape(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryFunction1DVectorViewShape, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryFunction1DVectorViewShape, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_UnaryFunction1DVectorViewShape(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryFunction1DVectorViewShape
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryFunction1DVectorViewShape_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryFunction1DVectorViewShape___call__(*args)
+    def setIntegrationType(*args): return _Freestyle.UnaryFunction1DVectorViewShape_setIntegrationType(*args)
+    def getIntegrationType(*args): return _Freestyle.UnaryFunction1DVectorViewShape_getIntegrationType(*args)
+UnaryFunction1DVectorViewShape_swigregister = _Freestyle.UnaryFunction1DVectorViewShape_swigregister
+UnaryFunction1DVectorViewShape_swigregister(UnaryFunction1DVectorViewShape)
+
+class GetXF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetXF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetXF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetXF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetXF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetXF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetXF1D
+    __del__ = lambda self : None;
+GetXF1D_swigregister = _Freestyle.GetXF1D_swigregister
+GetXF1D_swigregister(GetXF1D)
+
+class GetYF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetYF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetYF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetYF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetYF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetYF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetYF1D
+    __del__ = lambda self : None;
+GetYF1D_swigregister = _Freestyle.GetYF1D_swigregister
+GetYF1D_swigregister(GetYF1D)
+
+class GetZF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetZF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetZF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetZF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetZF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetZF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetZF1D
+    __del__ = lambda self : None;
+GetZF1D_swigregister = _Freestyle.GetZF1D_swigregister
+GetZF1D_swigregister(GetZF1D)
+
+class GetProjectedXF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedXF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedXF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedXF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetProjectedXF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedXF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetProjectedXF1D
+    __del__ = lambda self : None;
+GetProjectedXF1D_swigregister = _Freestyle.GetProjectedXF1D_swigregister
+GetProjectedXF1D_swigregister(GetProjectedXF1D)
+
+class GetProjectedYF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedYF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedYF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedYF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetProjectedYF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedYF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetProjectedYF1D
+    __del__ = lambda self : None;
+GetProjectedYF1D_swigregister = _Freestyle.GetProjectedYF1D_swigregister
+GetProjectedYF1D_swigregister(GetProjectedYF1D)
+
+class GetProjectedZF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetProjectedZF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetProjectedZF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetProjectedZF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetProjectedZF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetProjectedZF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetProjectedZF1D
+    __del__ = lambda self : None;
+GetProjectedZF1D_swigregister = _Freestyle.GetProjectedZF1D_swigregister
+GetProjectedZF1D_swigregister(GetProjectedZF1D)
+
+class Orientation2DF1D(UnaryFunction1DVec2f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVec2f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Orientation2DF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVec2f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Orientation2DF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Orientation2DF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.Orientation2DF1D_getName(*args)
+    def __call__(*args): return _Freestyle.Orientation2DF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_Orientation2DF1D
+    __del__ = lambda self : None;
+Orientation2DF1D_swigregister = _Freestyle.Orientation2DF1D_swigregister
+Orientation2DF1D_swigregister(Orientation2DF1D)
+
+class Orientation3DF1D(UnaryFunction1DVec3f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVec3f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Orientation3DF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVec3f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Orientation3DF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Orientation3DF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.Orientation3DF1D_getName(*args)
+    def __call__(*args): return _Freestyle.Orientation3DF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_Orientation3DF1D
+    __del__ = lambda self : None;
+Orientation3DF1D_swigregister = _Freestyle.Orientation3DF1D_swigregister
+Orientation3DF1D_swigregister(Orientation3DF1D)
+
+class ZDiscontinuityF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ZDiscontinuityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ZDiscontinuityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ZDiscontinuityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ZDiscontinuityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.ZDiscontinuityF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ZDiscontinuityF1D
+    __del__ = lambda self : None;
+ZDiscontinuityF1D_swigregister = _Freestyle.ZDiscontinuityF1D_swigregister
+ZDiscontinuityF1D_swigregister(ZDiscontinuityF1D)
+
+class QuantitativeInvisibilityF1D(UnaryFunction1DUnsigned):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DUnsigned]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, QuantitativeInvisibilityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DUnsigned]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, QuantitativeInvisibilityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_QuantitativeInvisibilityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.QuantitativeInvisibilityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.QuantitativeInvisibilityF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_QuantitativeInvisibilityF1D
+    __del__ = lambda self : None;
+QuantitativeInvisibilityF1D_swigregister = _Freestyle.QuantitativeInvisibilityF1D_swigregister
+QuantitativeInvisibilityF1D_swigregister(QuantitativeInvisibilityF1D)
+
+class CurveNatureF1D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CurveNatureF1D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, CurveNatureF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_CurveNatureF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.CurveNatureF1D_getName(*args)
+    def __call__(*args): return _Freestyle.CurveNatureF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_CurveNatureF1D
+    __del__ = lambda self : None;
+CurveNatureF1D_swigregister = _Freestyle.CurveNatureF1D_swigregister
+CurveNatureF1D_swigregister(CurveNatureF1D)
+
+class TimeStampF1D(UnaryFunction1DVoid):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeStampF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TimeStampF1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.TimeStampF1D_getName(*args)
+    def __call__(*args): return _Freestyle.TimeStampF1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_TimeStampF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_TimeStampF1D
+    __del__ = lambda self : None;
+TimeStampF1D_swigregister = _Freestyle.TimeStampF1D_swigregister
+TimeStampF1D_swigregister(TimeStampF1D)
+
+class IncrementChainingTimeStampF1D(UnaryFunction1DVoid):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IncrementChainingTimeStampF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, IncrementChainingTimeStampF1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.IncrementChainingTimeStampF1D_getName(*args)
+    def __call__(*args): return _Freestyle.IncrementChainingTimeStampF1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_IncrementChainingTimeStampF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_IncrementChainingTimeStampF1D
+    __del__ = lambda self : None;
+IncrementChainingTimeStampF1D_swigregister = _Freestyle.IncrementChainingTimeStampF1D_swigregister
+IncrementChainingTimeStampF1D_swigregister(IncrementChainingTimeStampF1D)
+
+class ChainingTimeStampF1D(UnaryFunction1DVoid):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainingTimeStampF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVoid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ChainingTimeStampF1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.ChainingTimeStampF1D_getName(*args)
+    def __call__(*args): return _Freestyle.ChainingTimeStampF1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ChainingTimeStampF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ChainingTimeStampF1D
+    __del__ = lambda self : None;
+ChainingTimeStampF1D_swigregister = _Freestyle.ChainingTimeStampF1D_swigregister
+ChainingTimeStampF1D_swigregister(ChainingTimeStampF1D)
+
+class Curvature2DAngleF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Curvature2DAngleF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Curvature2DAngleF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Curvature2DAngleF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.Curvature2DAngleF1D_getName(*args)
+    def __call__(*args): return _Freestyle.Curvature2DAngleF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_Curvature2DAngleF1D
+    __del__ = lambda self : None;
+Curvature2DAngleF1D_swigregister = _Freestyle.Curvature2DAngleF1D_swigregister
+Curvature2DAngleF1D_swigregister(Curvature2DAngleF1D)
+
+class Normal2DF1D(UnaryFunction1DVec2f):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVec2f]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Normal2DF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVec2f]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Normal2DF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Normal2DF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.Normal2DF1D_getName(*args)
+    def __call__(*args): return _Freestyle.Normal2DF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_Normal2DF1D
+    __del__ = lambda self : None;
+Normal2DF1D_swigregister = _Freestyle.Normal2DF1D_swigregister
+Normal2DF1D_swigregister(Normal2DF1D)
+
+class GetShapeF1D(UnaryFunction1DVectorViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetShapeF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetShapeF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetShapeF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetShapeF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetShapeF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetShapeF1D
+    __del__ = lambda self : None;
+GetShapeF1D_swigregister = _Freestyle.GetShapeF1D_swigregister
+GetShapeF1D_swigregister(GetShapeF1D)
+
+class GetOccludersF1D(UnaryFunction1DVectorViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetOccludersF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetOccludersF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetOccludersF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetOccludersF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetOccludersF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetOccludersF1D
+    __del__ = lambda self : None;
+GetOccludersF1D_swigregister = _Freestyle.GetOccludersF1D_swigregister
+GetOccludersF1D_swigregister(GetOccludersF1D)
+
+class GetOccludeeF1D(UnaryFunction1DVectorViewShape):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetOccludeeF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DVectorViewShape]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetOccludeeF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetOccludeeF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetOccludeeF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetOccludeeF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetOccludeeF1D
+    __del__ = lambda self : None;
+GetOccludeeF1D_swigregister = _Freestyle.GetOccludeeF1D_swigregister
+GetOccludeeF1D_swigregister(GetOccludeeF1D)
+
+class Module(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Module, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Module, name)
+    __repr__ = _swig_repr
+    __swig_getmethods__["setAlwaysRefresh"] = lambda x: _Freestyle.Module_setAlwaysRefresh
+    if _newclass:setAlwaysRefresh = staticmethod(_Freestyle.Module_setAlwaysRefresh)
+    __swig_getmethods__["setCausal"] = lambda x: _Freestyle.Module_setCausal
+    if _newclass:setCausal = staticmethod(_Freestyle.Module_setCausal)
+    __swig_getmethods__["setDrawable"] = lambda x: _Freestyle.Module_setDrawable
+    if _newclass:setDrawable = staticmethod(_Freestyle.Module_setDrawable)
+    __swig_getmethods__["getAlwaysRefresh"] = lambda x: _Freestyle.Module_getAlwaysRefresh
+    if _newclass:getAlwaysRefresh = staticmethod(_Freestyle.Module_getAlwaysRefresh)
+    __swig_getmethods__["getCausal"] = lambda x: _Freestyle.Module_getCausal
+    if _newclass:getCausal = staticmethod(_Freestyle.Module_getCausal)
+    __swig_getmethods__["getDrawable"] = lambda x: _Freestyle.Module_getDrawable
+    if _newclass:getDrawable = staticmethod(_Freestyle.Module_getDrawable)
+    def __init__(self, *args): 
+        this = _Freestyle.new_Module(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Module
+    __del__ = lambda self : None;
+Module_swigregister = _Freestyle.Module_swigregister
+Module_swigregister(Module)
+Module_setAlwaysRefresh = _Freestyle.Module_setAlwaysRefresh
+Module_setCausal = _Freestyle.Module_setCausal
+Module_setDrawable = _Freestyle.Module_setDrawable
+Module_getAlwaysRefresh = _Freestyle.Module_getAlwaysRefresh
+Module_getCausal = _Freestyle.Module_getCausal
+Module_getDrawable = _Freestyle.Module_getDrawable
+
+class DensityF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, DensityF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, DensityF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_DensityF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.DensityF0D_getName(*args)
+    def __call__(*args): return _Freestyle.DensityF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_DensityF0D
+    __del__ = lambda self : None;
+DensityF0D_swigregister = _Freestyle.DensityF0D_swigregister
+DensityF0D_swigregister(DensityF0D)
+
+class LocalAverageDepthF0D(UnaryFunction0DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalAverageDepthF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, LocalAverageDepthF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_LocalAverageDepthF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.LocalAverageDepthF0D_getName(*args)
+    def __call__(*args): return _Freestyle.LocalAverageDepthF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_LocalAverageDepthF0D
+    __del__ = lambda self : None;
+LocalAverageDepthF0D_swigregister = _Freestyle.LocalAverageDepthF0D_swigregister
+LocalAverageDepthF0D_swigregister(LocalAverageDepthF0D)
+
+class ReadMapPixelF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadMapPixelF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ReadMapPixelF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ReadMapPixelF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ReadMapPixelF0D_getName(*args)
+    def __call__(*args): return _Freestyle.ReadMapPixelF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ReadMapPixelF0D
+    __del__ = lambda self : None;
+ReadMapPixelF0D_swigregister = _Freestyle.ReadMapPixelF0D_swigregister
+ReadMapPixelF0D_swigregister(ReadMapPixelF0D)
+
+class ReadSteerableViewMapPixelF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadSteerableViewMapPixelF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ReadSteerableViewMapPixelF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ReadSteerableViewMapPixelF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ReadSteerableViewMapPixelF0D_getName(*args)
+    def __call__(*args): return _Freestyle.ReadSteerableViewMapPixelF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ReadSteerableViewMapPixelF0D
+    __del__ = lambda self : None;
+ReadSteerableViewMapPixelF0D_swigregister = _Freestyle.ReadSteerableViewMapPixelF0D_swigregister
+ReadSteerableViewMapPixelF0D_swigregister(ReadSteerableViewMapPixelF0D)
+
+class ReadCompleteViewMapPixelF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ReadCompleteViewMapPixelF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ReadCompleteViewMapPixelF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ReadCompleteViewMapPixelF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ReadCompleteViewMapPixelF0D_getName(*args)
+    def __call__(*args): return _Freestyle.ReadCompleteViewMapPixelF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ReadCompleteViewMapPixelF0D
+    __del__ = lambda self : None;
+ReadCompleteViewMapPixelF0D_swigregister = _Freestyle.ReadCompleteViewMapPixelF0D_swigregister
+ReadCompleteViewMapPixelF0D_swigregister(ReadCompleteViewMapPixelF0D)
+
+class GetViewMapGradientNormF0D(UnaryFunction0DFloat):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetViewMapGradientNormF0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction0DFloat]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetViewMapGradientNormF0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetViewMapGradientNormF0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetViewMapGradientNormF0D_getName(*args)
+    def __call__(*args): return _Freestyle.GetViewMapGradientNormF0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetViewMapGradientNormF0D
+    __del__ = lambda self : None;
+GetViewMapGradientNormF0D_swigregister = _Freestyle.GetViewMapGradientNormF0D_swigregister
+GetViewMapGradientNormF0D_swigregister(GetViewMapGradientNormF0D)
+
+class DensityF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, DensityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, DensityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_DensityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_DensityF1D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.DensityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.DensityF1D___call__(*args)
+DensityF1D_swigregister = _Freestyle.DensityF1D_swigregister
+DensityF1D_swigregister(DensityF1D)
+
+class LocalAverageDepthF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalAverageDepthF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, LocalAverageDepthF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_LocalAverageDepthF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.LocalAverageDepthF1D_getName(*args)
+    def __call__(*args): return _Freestyle.LocalAverageDepthF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_LocalAverageDepthF1D
+    __del__ = lambda self : None;
+LocalAverageDepthF1D_swigregister = _Freestyle.LocalAverageDepthF1D_swigregister
+LocalAverageDepthF1D_swigregister(LocalAverageDepthF1D)
+
+class GetCompleteViewMapDensityF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetCompleteViewMapDensityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetCompleteViewMapDensityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetCompleteViewMapDensityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetCompleteViewMapDensityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetCompleteViewMapDensityF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetCompleteViewMapDensityF1D
+    __del__ = lambda self : None;
+GetCompleteViewMapDensityF1D_swigregister = _Freestyle.GetCompleteViewMapDensityF1D_swigregister
+GetCompleteViewMapDensityF1D_swigregister(GetCompleteViewMapDensityF1D)
+
+class GetDirectionalViewMapDensityF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetDirectionalViewMapDensityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetDirectionalViewMapDensityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetDirectionalViewMapDensityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetDirectionalViewMapDensityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetDirectionalViewMapDensityF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetDirectionalViewMapDensityF1D
+    __del__ = lambda self : None;
+GetDirectionalViewMapDensityF1D_swigregister = _Freestyle.GetDirectionalViewMapDensityF1D_swigregister
+GetDirectionalViewMapDensityF1D_swigregister(GetDirectionalViewMapDensityF1D)
+
+class GetSteerableViewMapDensityF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetSteerableViewMapDensityF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetSteerableViewMapDensityF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetSteerableViewMapDensityF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_GetSteerableViewMapDensityF1D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.GetSteerableViewMapDensityF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetSteerableViewMapDensityF1D___call__(*args)
+GetSteerableViewMapDensityF1D_swigregister = _Freestyle.GetSteerableViewMapDensityF1D_swigregister
+GetSteerableViewMapDensityF1D_swigregister(GetSteerableViewMapDensityF1D)
+
+class GetViewMapGradientNormF1D(UnaryFunction1DDouble):
+    __swig_setmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GetViewMapGradientNormF1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryFunction1DDouble]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GetViewMapGradientNormF1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GetViewMapGradientNormF1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.GetViewMapGradientNormF1D_getName(*args)
+    def __call__(*args): return _Freestyle.GetViewMapGradientNormF1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_GetViewMapGradientNormF1D
+    __del__ = lambda self : None;
+GetViewMapGradientNormF1D_swigregister = _Freestyle.GetViewMapGradientNormF1D_swigregister
+GetViewMapGradientNormF1D_swigregister(GetViewMapGradientNormF1D)
+
+GetTimeStampCF = _Freestyle.GetTimeStampCF
+GetCanvasWidthCF = _Freestyle.GetCanvasWidthCF
+GetCanvasHeightCF = _Freestyle.GetCanvasHeightCF
+ReadMapPixelCF = _Freestyle.ReadMapPixelCF
+ReadCompleteViewMapPixelCF = _Freestyle.ReadCompleteViewMapPixelCF
+ReadDirectionalViewMapPixelCF = _Freestyle.ReadDirectionalViewMapPixelCF
+GetSelectedFEdgeCF = _Freestyle.GetSelectedFEdgeCF
+class AdjacencyIterator(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, AdjacencyIterator, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, AdjacencyIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_AdjacencyIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_AdjacencyIterator
+    __del__ = lambda self : None;
+    def isEnd(*args): return _Freestyle.AdjacencyIterator_isEnd(*args)
+    def isBegin(*args): return _Freestyle.AdjacencyIterator_isBegin(*args)
+    def isIncoming(*args): return _Freestyle.AdjacencyIterator_isIncoming(*args)
+    def getObject(*args): return _Freestyle.AdjacencyIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.AdjacencyIterator___deref__(*args)
+    def increment(*args): return _Freestyle.AdjacencyIterator_increment(*args)
+    def getExactTypeName(*args): return _Freestyle.AdjacencyIterator_getExactTypeName(*args)
+    def getId(*args): return _Freestyle.AdjacencyIterator_getId(*args)
+    def getNature(*args): return _Freestyle.AdjacencyIterator_getNature(*args)
+    __swig_setmethods__["userdata"] = _Freestyle.AdjacencyIterator_userdata_set
+    __swig_getmethods__["userdata"] = _Freestyle.AdjacencyIterator_userdata_get
+    if _newclass:userdata = _swig_property(_Freestyle.AdjacencyIterator_userdata_get, _Freestyle.AdjacencyIterator_userdata_set)
+    def A(*args): return _Freestyle.AdjacencyIterator_A(*args)
+    def B(*args): return _Freestyle.AdjacencyIterator_B(*args)
+    def fedgeA(*args): return _Freestyle.AdjacencyIterator_fedgeA(*args)
+    def fedgeB(*args): return _Freestyle.AdjacencyIterator_fedgeB(*args)
+    def viewShape(*args): return _Freestyle.AdjacencyIterator_viewShape(*args)
+    def aShape(*args): return _Freestyle.AdjacencyIterator_aShape(*args)
+    def isClosed(*args): return _Freestyle.AdjacencyIterator_isClosed(*args)
+    def getChainingTimeStamp(*args): return _Freestyle.AdjacencyIterator_getChainingTimeStamp(*args)
+    def bShape(*args): return _Freestyle.AdjacencyIterator_bShape(*args)
+    def occluders(*args): return _Freestyle.AdjacencyIterator_occluders(*args)
+    def splittingId(*args): return _Freestyle.AdjacencyIterator_splittingId(*args)
+    def setA(*args): return _Freestyle.AdjacencyIterator_setA(*args)
+    def setB(*args): return _Freestyle.AdjacencyIterator_setB(*args)
+    def setNature(*args): return _Freestyle.AdjacencyIterator_setNature(*args)
+    def setFEdgeA(*args): return _Freestyle.AdjacencyIterator_setFEdgeA(*args)
+    def setFEdgeB(*args): return _Freestyle.AdjacencyIterator_setFEdgeB(*args)
+    def setShape(*args): return _Freestyle.AdjacencyIterator_setShape(*args)
+    def setId(*args): return _Freestyle.AdjacencyIterator_setId(*args)
+    def UpdateFEdges(*args): return _Freestyle.AdjacencyIterator_UpdateFEdges(*args)
+    def setaShape(*args): return _Freestyle.AdjacencyIterator_setaShape(*args)
+    def setQI(*args): return _Freestyle.AdjacencyIterator_setQI(*args)
+    def setChainingTimeStamp(*args): return _Freestyle.AdjacencyIterator_setChainingTimeStamp(*args)
+    def AddOccluder(*args): return _Freestyle.AdjacencyIterator_AddOccluder(*args)
+    def setSplittingId(*args): return _Freestyle.AdjacencyIterator_setSplittingId(*args)
+    def intersect_2d_area(*args): return _Freestyle.AdjacencyIterator_intersect_2d_area(*args)
+    def include_in_2d_area(*args): return _Freestyle.AdjacencyIterator_include_in_2d_area(*args)
+    def getLength2D(*args): return _Freestyle.AdjacencyIterator_getLength2D(*args)
+    def qi(*args): return _Freestyle.AdjacencyIterator_qi(*args)
+    def occluders_begin(*args): return _Freestyle.AdjacencyIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.AdjacencyIterator_occluders_end(*args)
+    def occluders_size(*args): return _Freestyle.AdjacencyIterator_occluders_size(*args)
+    def occluders_empty(*args): return _Freestyle.AdjacencyIterator_occluders_empty(*args)
+    def occludee(*args): return _Freestyle.AdjacencyIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.AdjacencyIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.AdjacencyIterator_occludee_empty(*args)
+    def shape_id(*args): return _Freestyle.AdjacencyIterator_shape_id(*args)
+    def shape(*args): return _Freestyle.AdjacencyIterator_shape(*args)
+    def shape_importance(*args): return _Freestyle.AdjacencyIterator_shape_importance(*args)
+    def verticesBegin(*args): return _Freestyle.AdjacencyIterator_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.AdjacencyIterator_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.AdjacencyIterator_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.AdjacencyIterator_pointsEnd(*args)
+    def getTimeStamp(*args): return _Freestyle.AdjacencyIterator_getTimeStamp(*args)
+    def setTimeStamp(*args): return _Freestyle.AdjacencyIterator_setTimeStamp(*args)
+AdjacencyIterator_swigregister = _Freestyle.AdjacencyIterator_swigregister
+AdjacencyIterator_swigregister(AdjacencyIterator)
+LoadMapCF = _Freestyle.LoadMapCF
+
+class ChainingIterator(ViewEdgeViewEdgeIterator):
+    __swig_setmethods__ = {}
+    for _s in [ViewEdgeViewEdgeIterator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainingIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [ViewEdgeViewEdgeIterator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ChainingIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == ChainingIterator:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_ChainingIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getExactTypeName(*args): return _Freestyle.ChainingIterator_getExactTypeName(*args)
+    def init(*args): return _Freestyle.ChainingIterator_init(*args)
+    def traverse(*args): return _Freestyle.ChainingIterator_traverse(*args)
+    def getVertex(*args): return _Freestyle.ChainingIterator_getVertex(*args)
+    def isIncrementing(*args): return _Freestyle.ChainingIterator_isIncrementing(*args)
+    def increment(*args): return _Freestyle.ChainingIterator_increment(*args)
+    def decrement(*args): return _Freestyle.ChainingIterator_decrement(*args)
+    __swig_destroy__ = _Freestyle.delete_ChainingIterator
+    __del__ = lambda self : None;
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_ChainingIterator(self)
+        return weakref_proxy(self)
+ChainingIterator_swigregister = _Freestyle.ChainingIterator_swigregister
+ChainingIterator_swigregister(ChainingIterator)
+
+class ChainSilhouetteIterator(ChainingIterator):
+    __swig_setmethods__ = {}
+    for _s in [ChainingIterator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainSilhouetteIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [ChainingIterator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ChainSilhouetteIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == ChainSilhouetteIterator:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_ChainSilhouetteIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getExactTypeName(*args): return _Freestyle.ChainSilhouetteIterator_getExactTypeName(*args)
+    def traverse(*args): return _Freestyle.ChainSilhouetteIterator_traverse(*args)
+    __swig_destroy__ = _Freestyle.delete_ChainSilhouetteIterator
+    __del__ = lambda self : None;
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_ChainSilhouetteIterator(self)
+        return weakref_proxy(self)
+ChainSilhouetteIterator_swigregister = _Freestyle.ChainSilhouetteIterator_swigregister
+ChainSilhouetteIterator_swigregister(ChainSilhouetteIterator)
+
+class ChainPredicateIterator(ChainingIterator):
+    __swig_setmethods__ = {}
+    for _s in [ChainingIterator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainPredicateIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [ChainingIterator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ChainPredicateIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == ChainPredicateIterator:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_ChainPredicateIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ChainPredicateIterator
+    __del__ = lambda self : None;
+    def getExactTypeName(*args): return _Freestyle.ChainPredicateIterator_getExactTypeName(*args)
+    def traverse(*args): return _Freestyle.ChainPredicateIterator_traverse(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_ChainPredicateIterator(self)
+        return weakref_proxy(self)
+ChainPredicateIterator_swigregister = _Freestyle.ChainPredicateIterator_swigregister
+ChainPredicateIterator_swigregister(ChainPredicateIterator)
+
+class UnaryPredicate0D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryPredicate0D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryPredicate0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryPredicate0D:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryPredicate0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryPredicate0D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryPredicate0D_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryPredicate0D___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryPredicate0D(self)
+        return weakref_proxy(self)
+UnaryPredicate0D_swigregister = _Freestyle.UnaryPredicate0D_swigregister
+UnaryPredicate0D_swigregister(UnaryPredicate0D)
+
+class BinaryPredicate0D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, BinaryPredicate0D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, BinaryPredicate0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_BinaryPredicate0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_BinaryPredicate0D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.BinaryPredicate0D_getName(*args)
+    def __call__(*args): return _Freestyle.BinaryPredicate0D___call__(*args)
+BinaryPredicate0D_swigregister = _Freestyle.BinaryPredicate0D_swigregister
+BinaryPredicate0D_swigregister(BinaryPredicate0D)
+
+class TrueUP0D(UnaryPredicate0D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate0D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TrueUP0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate0D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TrueUP0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_TrueUP0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.TrueUP0D_getName(*args)
+    def __call__(*args): return _Freestyle.TrueUP0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_TrueUP0D
+    __del__ = lambda self : None;
+TrueUP0D_swigregister = _Freestyle.TrueUP0D_swigregister
+TrueUP0D_swigregister(TrueUP0D)
+
+class FalseUP0D(UnaryPredicate0D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate0D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FalseUP0D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate0D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FalseUP0D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_FalseUP0D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.FalseUP0D_getName(*args)
+    def __call__(*args): return _Freestyle.FalseUP0D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_FalseUP0D
+    __del__ = lambda self : None;
+FalseUP0D_swigregister = _Freestyle.FalseUP0D_swigregister
+FalseUP0D_swigregister(FalseUP0D)
+
+class UnaryPredicate1D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UnaryPredicate1D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UnaryPredicate1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == UnaryPredicate1D:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_UnaryPredicate1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_UnaryPredicate1D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.UnaryPredicate1D_getName(*args)
+    def __call__(*args): return _Freestyle.UnaryPredicate1D___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_UnaryPredicate1D(self)
+        return weakref_proxy(self)
+UnaryPredicate1D_swigregister = _Freestyle.UnaryPredicate1D_swigregister
+UnaryPredicate1D_swigregister(UnaryPredicate1D)
+
+class BinaryPredicate1D(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, BinaryPredicate1D, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, BinaryPredicate1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == BinaryPredicate1D:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_BinaryPredicate1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_BinaryPredicate1D
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.BinaryPredicate1D_getName(*args)
+    def __call__(*args): return _Freestyle.BinaryPredicate1D___call__(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_BinaryPredicate1D(self)
+        return weakref_proxy(self)
+BinaryPredicate1D_swigregister = _Freestyle.BinaryPredicate1D_swigregister
+BinaryPredicate1D_swigregister(BinaryPredicate1D)
+
+class TrueUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TrueUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TrueUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_TrueUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.TrueUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.TrueUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_TrueUP1D
+    __del__ = lambda self : None;
+TrueUP1D_swigregister = _Freestyle.TrueUP1D_swigregister
+TrueUP1D_swigregister(TrueUP1D)
+
+class FalseUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FalseUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FalseUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_FalseUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.FalseUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.FalseUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_FalseUP1D
+    __del__ = lambda self : None;
+FalseUP1D_swigregister = _Freestyle.FalseUP1D_swigregister
+FalseUP1D_swigregister(FalseUP1D)
+
+class QuantitativeInvisibilityUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, QuantitativeInvisibilityUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, QuantitativeInvisibilityUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_QuantitativeInvisibilityUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.QuantitativeInvisibilityUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.QuantitativeInvisibilityUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_QuantitativeInvisibilityUP1D
+    __del__ = lambda self : None;
+QuantitativeInvisibilityUP1D_swigregister = _Freestyle.QuantitativeInvisibilityUP1D_swigregister
+QuantitativeInvisibilityUP1D_swigregister(QuantitativeInvisibilityUP1D)
+
+class ContourUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ContourUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ContourUP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.ContourUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.ContourUP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ContourUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ContourUP1D
+    __del__ = lambda self : None;
+ContourUP1D_swigregister = _Freestyle.ContourUP1D_swigregister
+ContourUP1D_swigregister(ContourUP1D)
+
+class ExternalContourUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ExternalContourUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ExternalContourUP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.ExternalContourUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.ExternalContourUP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ExternalContourUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ExternalContourUP1D
+    __del__ = lambda self : None;
+ExternalContourUP1D_swigregister = _Freestyle.ExternalContourUP1D_swigregister
+ExternalContourUP1D_swigregister(ExternalContourUP1D)
+
+class EqualToTimeStampUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, EqualToTimeStampUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, EqualToTimeStampUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_EqualToTimeStampUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.EqualToTimeStampUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.EqualToTimeStampUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_EqualToTimeStampUP1D
+    __del__ = lambda self : None;
+EqualToTimeStampUP1D_swigregister = _Freestyle.EqualToTimeStampUP1D_swigregister
+EqualToTimeStampUP1D_swigregister(EqualToTimeStampUP1D)
+
+class EqualToChainingTimeStampUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, EqualToChainingTimeStampUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, EqualToChainingTimeStampUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_EqualToChainingTimeStampUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.EqualToChainingTimeStampUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.EqualToChainingTimeStampUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_EqualToChainingTimeStampUP1D
+    __del__ = lambda self : None;
+EqualToChainingTimeStampUP1D_swigregister = _Freestyle.EqualToChainingTimeStampUP1D_swigregister
+EqualToChainingTimeStampUP1D_swigregister(EqualToChainingTimeStampUP1D)
+
+class ShapeUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ShapeUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ShapeUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ShapeUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ShapeUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.ShapeUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ShapeUP1D
+    __del__ = lambda self : None;
+ShapeUP1D_swigregister = _Freestyle.ShapeUP1D_swigregister
+ShapeUP1D_swigregister(ShapeUP1D)
+
+class TrueBP1D(BinaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TrueBP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TrueBP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.TrueBP1D_getName(*args)
+    def __call__(*args): return _Freestyle.TrueBP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_TrueBP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_TrueBP1D
+    __del__ = lambda self : None;
+TrueBP1D_swigregister = _Freestyle.TrueBP1D_swigregister
+TrueBP1D_swigregister(TrueBP1D)
+
+class FalseBP1D(BinaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FalseBP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FalseBP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.FalseBP1D_getName(*args)
+    def __call__(*args): return _Freestyle.FalseBP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_FalseBP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_FalseBP1D
+    __del__ = lambda self : None;
+FalseBP1D_swigregister = _Freestyle.FalseBP1D_swigregister
+FalseBP1D_swigregister(FalseBP1D)
+
+class Length2DBP1D(BinaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Length2DBP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Length2DBP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.Length2DBP1D_getName(*args)
+    def __call__(*args): return _Freestyle.Length2DBP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_Length2DBP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Length2DBP1D
+    __del__ = lambda self : None;
+Length2DBP1D_swigregister = _Freestyle.Length2DBP1D_swigregister
+Length2DBP1D_swigregister(Length2DBP1D)
+
+class SameShapeIdBP1D(BinaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SameShapeIdBP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, SameShapeIdBP1D, name)
+    __repr__ = _swig_repr
+    def getName(*args): return _Freestyle.SameShapeIdBP1D_getName(*args)
+    def __call__(*args): return _Freestyle.SameShapeIdBP1D___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_SameShapeIdBP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_SameShapeIdBP1D
+    __del__ = lambda self : None;
+SameShapeIdBP1D_swigregister = _Freestyle.SameShapeIdBP1D_swigregister
+SameShapeIdBP1D_swigregister(SameShapeIdBP1D)
+
+class ViewMapGradientNormBP1D(BinaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ViewMapGradientNormBP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [BinaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ViewMapGradientNormBP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ViewMapGradientNormBP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ViewMapGradientNormBP1D_getName(*args)
+    def __call__(*args): return _Freestyle.ViewMapGradientNormBP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_ViewMapGradientNormBP1D
+    __del__ = lambda self : None;
+ViewMapGradientNormBP1D_swigregister = _Freestyle.ViewMapGradientNormBP1D_swigregister
+ViewMapGradientNormBP1D_swigregister(ViewMapGradientNormBP1D)
+
+class DensityLowerThanUP1D(UnaryPredicate1D):
+    __swig_setmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, DensityLowerThanUP1D, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UnaryPredicate1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, DensityLowerThanUP1D, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_DensityLowerThanUP1D(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.DensityLowerThanUP1D_getName(*args)
+    def __call__(*args): return _Freestyle.DensityLowerThanUP1D___call__(*args)
+    __swig_destroy__ = _Freestyle.delete_DensityLowerThanUP1D
+    __del__ = lambda self : None;
+DensityLowerThanUP1D_swigregister = _Freestyle.DensityLowerThanUP1D_swigregister
+DensityLowerThanUP1D_swigregister(DensityLowerThanUP1D)
+
+class CurvePointIterator(Interface0DIteratorNested):
+    __swig_setmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CurvePointIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, CurvePointIterator, name)
+    __repr__ = _swig_repr
+    __swig_setmethods__["_CurvilinearLength"] = _Freestyle.CurvePointIterator__CurvilinearLength_set
+    __swig_getmethods__["_CurvilinearLength"] = _Freestyle.CurvePointIterator__CurvilinearLength_get
+    if _newclass:_CurvilinearLength = _swig_property(_Freestyle.CurvePointIterator__CurvilinearLength_get, _Freestyle.CurvePointIterator__CurvilinearLength_set)
+    __swig_setmethods__["_step"] = _Freestyle.CurvePointIterator__step_set
+    __swig_getmethods__["_step"] = _Freestyle.CurvePointIterator__step_get
+    if _newclass:_step = _swig_property(_Freestyle.CurvePointIterator__step_get, _Freestyle.CurvePointIterator__step_set)
+    __swig_setmethods__["__A"] = _Freestyle.CurvePointIterator___A_set
+    __swig_getmethods__["__A"] = _Freestyle.CurvePointIterator___A_get
+    if _newclass:__A = _swig_property(_Freestyle.CurvePointIterator___A_get, _Freestyle.CurvePointIterator___A_set)
+    __swig_setmethods__["__B"] = _Freestyle.CurvePointIterator___B_set
+    __swig_getmethods__["__B"] = _Freestyle.CurvePointIterator___B_get
+    if _newclass:__B = _swig_property(_Freestyle.CurvePointIterator___B_get, _Freestyle.CurvePointIterator___B_set)
+    __swig_setmethods__["_begin"] = _Freestyle.CurvePointIterator__begin_set
+    __swig_getmethods__["_begin"] = _Freestyle.CurvePointIterator__begin_get
+    if _newclass:_begin = _swig_property(_Freestyle.CurvePointIterator__begin_get, _Freestyle.CurvePointIterator__begin_set)
+    __swig_setmethods__["_end"] = _Freestyle.CurvePointIterator__end_set
+    __swig_getmethods__["_end"] = _Freestyle.CurvePointIterator__end_get
+    if _newclass:_end = _swig_property(_Freestyle.CurvePointIterator__end_get, _Freestyle.CurvePointIterator__end_set)
+    __swig_setmethods__["_n"] = _Freestyle.CurvePointIterator__n_set
+    __swig_getmethods__["_n"] = _Freestyle.CurvePointIterator__n_get
+    if _newclass:_n = _swig_property(_Freestyle.CurvePointIterator__n_get, _Freestyle.CurvePointIterator__n_set)
+    __swig_setmethods__["_currentn"] = _Freestyle.CurvePointIterator__currentn_set
+    __swig_getmethods__["_currentn"] = _Freestyle.CurvePointIterator__currentn_get
+    if _newclass:_currentn = _swig_property(_Freestyle.CurvePointIterator__currentn_get, _Freestyle.CurvePointIterator__currentn_set)
+    __swig_setmethods__["_t"] = _Freestyle.CurvePointIterator__t_set
+    __swig_getmethods__["_t"] = _Freestyle.CurvePointIterator__t_get
+    if _newclass:_t = _swig_property(_Freestyle.CurvePointIterator__t_get, _Freestyle.CurvePointIterator__t_set)
+    __swig_setmethods__["_Point"] = _Freestyle.CurvePointIterator__Point_set
+    __swig_getmethods__["_Point"] = _Freestyle.CurvePointIterator__Point_get
+    if _newclass:_Point = _swig_property(_Freestyle.CurvePointIterator__Point_get, _Freestyle.CurvePointIterator__Point_set)
+    __swig_setmethods__["_CurveLength"] = _Freestyle.CurvePointIterator__CurveLength_set
+    __swig_getmethods__["_CurveLength"] = _Freestyle.CurvePointIterator__CurveLength_get
+    if _newclass:_CurveLength = _swig_property(_Freestyle.CurvePointIterator__CurveLength_get, _Freestyle.CurvePointIterator__CurveLength_set)
+    def __init__(self, *args): 
+        this = _Freestyle.new_CurvePointIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_CurvePointIterator
+    __del__ = lambda self : None;
+    def copy(*args): return _Freestyle.CurvePointIterator_copy(*args)
+    def CastToInterface0DIterator(*args): return _Freestyle.CurvePointIterator_CastToInterface0DIterator(*args)
+    def getExactTypeName(*args): return _Freestyle.CurvePointIterator_getExactTypeName(*args)
+    def __eq__(*args): return _Freestyle.CurvePointIterator___eq__(*args)
+    def getObject(*args): return _Freestyle.CurvePointIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.CurvePointIterator___deref__(*args)
+    def isBegin(*args): return _Freestyle.CurvePointIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.CurvePointIterator_isEnd(*args)
+    def getX(*args): return _Freestyle.CurvePointIterator_getX(*args)
+    def getY(*args): return _Freestyle.CurvePointIterator_getY(*args)
+    def getZ(*args): return _Freestyle.CurvePointIterator_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.CurvePointIterator_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.CurvePointIterator_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.CurvePointIterator_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.CurvePointIterator_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.CurvePointIterator_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.CurvePointIterator_getFEdge(*args)
+    def getId(*args): return _Freestyle.CurvePointIterator_getId(*args)
+    def getNature(*args): return _Freestyle.CurvePointIterator_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.CurvePointIterator_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.CurvePointIterator_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.CurvePointIterator_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.CurvePointIterator_castToTVertex(*args)
+    def A(*args): return _Freestyle.CurvePointIterator_A(*args)
+    def B(*args): return _Freestyle.CurvePointIterator_B(*args)
+    def t2d(*args): return _Freestyle.CurvePointIterator_t2d(*args)
+    def setA(*args): return _Freestyle.CurvePointIterator_setA(*args)
+    def setB(*args): return _Freestyle.CurvePointIterator_setB(*args)
+    def setT2d(*args): return _Freestyle.CurvePointIterator_setT2d(*args)
+    def fedge(*args): return _Freestyle.CurvePointIterator_fedge(*args)
+    def point2d(*args): return _Freestyle.CurvePointIterator_point2d(*args)
+    def point3d(*args): return _Freestyle.CurvePointIterator_point3d(*args)
+    def normal(*args): return _Freestyle.CurvePointIterator_normal(*args)
+    def shape(*args): return _Freestyle.CurvePointIterator_shape(*args)
+    def occluders_begin(*args): return _Freestyle.CurvePointIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.CurvePointIterator_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.CurvePointIterator_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.CurvePointIterator_occluders_size(*args)
+    def occludee(*args): return _Freestyle.CurvePointIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.CurvePointIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.CurvePointIterator_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.CurvePointIterator_z_discontinuity(*args)
+    def curvatureFredo(*args): return _Freestyle.CurvePointIterator_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.CurvePointIterator_directionFredo(*args)
+CurvePointIterator_swigregister = _Freestyle.CurvePointIterator_swigregister
+CurvePointIterator_swigregister(CurvePointIterator)
+
+class CurvePoint(Interface0D):
+    __swig_setmethods__ = {}
+    for _s in [Interface0D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CurvePoint, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, CurvePoint, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.CurvePoint_getExactTypeName(*args)
+    def getX(*args): return _Freestyle.CurvePoint_getX(*args)
+    def getY(*args): return _Freestyle.CurvePoint_getY(*args)
+    def getZ(*args): return _Freestyle.CurvePoint_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.CurvePoint_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.CurvePoint_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.CurvePoint_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.CurvePoint_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.CurvePoint_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.CurvePoint_getFEdge(*args)
+    def getId(*args): return _Freestyle.CurvePoint_getId(*args)
+    def getNature(*args): return _Freestyle.CurvePoint_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.CurvePoint_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.CurvePoint_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.CurvePoint_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.CurvePoint_castToTVertex(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_CurvePoint(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_CurvePoint
+    __del__ = lambda self : None;
+    def __eq__(*args): return _Freestyle.CurvePoint___eq__(*args)
+    def A(*args): return _Freestyle.CurvePoint_A(*args)
+    def B(*args): return _Freestyle.CurvePoint_B(*args)
+    def t2d(*args): return _Freestyle.CurvePoint_t2d(*args)
+    def setA(*args): return _Freestyle.CurvePoint_setA(*args)
+    def setB(*args): return _Freestyle.CurvePoint_setB(*args)
+    def setT2d(*args): return _Freestyle.CurvePoint_setT2d(*args)
+    def fedge(*args): return _Freestyle.CurvePoint_fedge(*args)
+    def point2d(*args): return _Freestyle.CurvePoint_point2d(*args)
+    def point3d(*args): return _Freestyle.CurvePoint_point3d(*args)
+    def normal(*args): return _Freestyle.CurvePoint_normal(*args)
+    def shape(*args): return _Freestyle.CurvePoint_shape(*args)
+    def occluders_begin(*args): return _Freestyle.CurvePoint_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.CurvePoint_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.CurvePoint_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.CurvePoint_occluders_size(*args)
+    def occludee(*args): return _Freestyle.CurvePoint_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.CurvePoint_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.CurvePoint_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.CurvePoint_z_discontinuity(*args)
+    def curvatureFredo(*args): return _Freestyle.CurvePoint_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.CurvePoint_directionFredo(*args)
+CurvePoint_swigregister = _Freestyle.CurvePoint_swigregister
+CurvePoint_swigregister(CurvePoint)
+
+class Curve(Interface1D):
+    __swig_setmethods__ = {}
+    for _s in [Interface1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Curve, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Curve, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Curve(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Curve
+    __del__ = lambda self : None;
+    def computeCurvatureAndOrientation(*args): return _Freestyle.Curve_computeCurvatureAndOrientation(*args)
+    def push_vertex_back(*args): return _Freestyle.Curve_push_vertex_back(*args)
+    def push_vertex_front(*args): return _Freestyle.Curve_push_vertex_front(*args)
+    def empty(*args): return _Freestyle.Curve_empty(*args)
+    def getLength2D(*args): return _Freestyle.Curve_getLength2D(*args)
+    def getId(*args): return _Freestyle.Curve_getId(*args)
+    def nSegments(*args): return _Freestyle.Curve_nSegments(*args)
+    def setId(*args): return _Freestyle.Curve_setId(*args)
+    def curvePointsBegin(*args): return _Freestyle.Curve_curvePointsBegin(*args)
+    def curvePointsEnd(*args): return _Freestyle.Curve_curvePointsEnd(*args)
+    def curveVerticesBegin(*args): return _Freestyle.Curve_curveVerticesBegin(*args)
+    def curveVerticesEnd(*args): return _Freestyle.Curve_curveVerticesEnd(*args)
+    def verticesBegin(*args): return _Freestyle.Curve_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.Curve_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.Curve_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.Curve_pointsEnd(*args)
+Curve_swigregister = _Freestyle.Curve_swigregister
+Curve_swigregister(Curve)
+
+class StrokeVertexIterator(Interface0DIteratorNested):
+    __swig_setmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, StrokeVertexIterator, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface0DIteratorNested]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, StrokeVertexIterator, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_StrokeVertexIterator(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_StrokeVertexIterator
+    __del__ = lambda self : None;
+    def castToInterface0DIterator(*args): return _Freestyle.StrokeVertexIterator_castToInterface0DIterator(*args)
+    def getExactTypeName(*args): return _Freestyle.StrokeVertexIterator_getExactTypeName(*args)
+    def getObject(*args): return _Freestyle.StrokeVertexIterator_getObject(*args)
+    def __deref__(*args): return _Freestyle.StrokeVertexIterator___deref__(*args)
+    def increment(*args): return _Freestyle.StrokeVertexIterator_increment(*args)
+    def decrement(*args): return _Freestyle.StrokeVertexIterator_decrement(*args)
+    def isBegin(*args): return _Freestyle.StrokeVertexIterator_isBegin(*args)
+    def isEnd(*args): return _Freestyle.StrokeVertexIterator_isEnd(*args)
+    def __eq__(*args): return _Freestyle.StrokeVertexIterator___eq__(*args)
+    def t(*args): return _Freestyle.StrokeVertexIterator_t(*args)
+    def u(*args): return _Freestyle.StrokeVertexIterator_u(*args)
+    def copy(*args): return _Freestyle.StrokeVertexIterator_copy(*args)
+    def getIt(*args): return _Freestyle.StrokeVertexIterator_getIt(*args)
+    def x(*args): return _Freestyle.StrokeVertexIterator_x(*args)
+    def y(*args): return _Freestyle.StrokeVertexIterator_y(*args)
+    def getPoint(*args): return _Freestyle.StrokeVertexIterator_getPoint(*args)
+    def attribute(*args): return _Freestyle.StrokeVertexIterator_attribute(*args)
+    def curvilinearAbscissa(*args): return _Freestyle.StrokeVertexIterator_curvilinearAbscissa(*args)
+    def strokeLength(*args): return _Freestyle.StrokeVertexIterator_strokeLength(*args)
+    def setX(*args): return _Freestyle.StrokeVertexIterator_setX(*args)
+    def setY(*args): return _Freestyle.StrokeVertexIterator_setY(*args)
+    def setPoint(*args): return _Freestyle.StrokeVertexIterator_setPoint(*args)
+    def setAttribute(*args): return _Freestyle.StrokeVertexIterator_setAttribute(*args)
+    def setCurvilinearAbscissa(*args): return _Freestyle.StrokeVertexIterator_setCurvilinearAbscissa(*args)
+    def setStrokeLength(*args): return _Freestyle.StrokeVertexIterator_setStrokeLength(*args)
+    def getX(*args): return _Freestyle.StrokeVertexIterator_getX(*args)
+    def getY(*args): return _Freestyle.StrokeVertexIterator_getY(*args)
+    def getZ(*args): return _Freestyle.StrokeVertexIterator_getZ(*args)
+    def getPoint3D(*args): return _Freestyle.StrokeVertexIterator_getPoint3D(*args)
+    def getProjectedX(*args): return _Freestyle.StrokeVertexIterator_getProjectedX(*args)
+    def getProjectedY(*args): return _Freestyle.StrokeVertexIterator_getProjectedY(*args)
+    def getProjectedZ(*args): return _Freestyle.StrokeVertexIterator_getProjectedZ(*args)
+    def getPoint2D(*args): return _Freestyle.StrokeVertexIterator_getPoint2D(*args)
+    def getFEdge(*args): return _Freestyle.StrokeVertexIterator_getFEdge(*args)
+    def getId(*args): return _Freestyle.StrokeVertexIterator_getId(*args)
+    def getNature(*args): return _Freestyle.StrokeVertexIterator_getNature(*args)
+    def castToSVertex(*args): return _Freestyle.StrokeVertexIterator_castToSVertex(*args)
+    def castToViewVertex(*args): return _Freestyle.StrokeVertexIterator_castToViewVertex(*args)
+    def castToNonTVertex(*args): return _Freestyle.StrokeVertexIterator_castToNonTVertex(*args)
+    def castToTVertex(*args): return _Freestyle.StrokeVertexIterator_castToTVertex(*args)
+    def A(*args): return _Freestyle.StrokeVertexIterator_A(*args)
+    def B(*args): return _Freestyle.StrokeVertexIterator_B(*args)
+    def t2d(*args): return _Freestyle.StrokeVertexIterator_t2d(*args)
+    def setA(*args): return _Freestyle.StrokeVertexIterator_setA(*args)
+    def setB(*args): return _Freestyle.StrokeVertexIterator_setB(*args)
+    def setT2d(*args): return _Freestyle.StrokeVertexIterator_setT2d(*args)
+    def fedge(*args): return _Freestyle.StrokeVertexIterator_fedge(*args)
+    def point2d(*args): return _Freestyle.StrokeVertexIterator_point2d(*args)
+    def point3d(*args): return _Freestyle.StrokeVertexIterator_point3d(*args)
+    def normal(*args): return _Freestyle.StrokeVertexIterator_normal(*args)
+    def shape(*args): return _Freestyle.StrokeVertexIterator_shape(*args)
+    def occluders_begin(*args): return _Freestyle.StrokeVertexIterator_occluders_begin(*args)
+    def occluders_end(*args): return _Freestyle.StrokeVertexIterator_occluders_end(*args)
+    def occluders_empty(*args): return _Freestyle.StrokeVertexIterator_occluders_empty(*args)
+    def occluders_size(*args): return _Freestyle.StrokeVertexIterator_occluders_size(*args)
+    def occludee(*args): return _Freestyle.StrokeVertexIterator_occludee(*args)
+    def occluded_shape(*args): return _Freestyle.StrokeVertexIterator_occluded_shape(*args)
+    def occludee_empty(*args): return _Freestyle.StrokeVertexIterator_occludee_empty(*args)
+    def z_discontinuity(*args): return _Freestyle.StrokeVertexIterator_z_discontinuity(*args)
+    def curvatureFredo(*args): return _Freestyle.StrokeVertexIterator_curvatureFredo(*args)
+    def directionFredo(*args): return _Freestyle.StrokeVertexIterator_directionFredo(*args)
+StrokeVertexIterator_swigregister = _Freestyle.StrokeVertexIterator_swigregister
+StrokeVertexIterator_swigregister(StrokeVertexIterator)
+
+class StrokeAttribute(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, StrokeAttribute, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, StrokeAttribute, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_StrokeAttribute(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_StrokeAttribute
+    __del__ = lambda self : None;
+    def getColor(*args): return _Freestyle.StrokeAttribute_getColor(*args)
+    def getColorR(*args): return _Freestyle.StrokeAttribute_getColorR(*args)
+    def getColorG(*args): return _Freestyle.StrokeAttribute_getColorG(*args)
+    def getColorB(*args): return _Freestyle.StrokeAttribute_getColorB(*args)
+    def getColorRGB(*args): return _Freestyle.StrokeAttribute_getColorRGB(*args)
+    def getAlpha(*args): return _Freestyle.StrokeAttribute_getAlpha(*args)
+    def getThickness(*args): return _Freestyle.StrokeAttribute_getThickness(*args)
+    def getThicknessR(*args): return _Freestyle.StrokeAttribute_getThicknessR(*args)
+    def getThicknessL(*args): return _Freestyle.StrokeAttribute_getThicknessL(*args)
+    def getThicknessRL(*args): return _Freestyle.StrokeAttribute_getThicknessRL(*args)
+    def isVisible(*args): return _Freestyle.StrokeAttribute_isVisible(*args)
+    def getAttributeReal(*args): return _Freestyle.StrokeAttribute_getAttributeReal(*args)
+    def getAttributeVec2f(*args): return _Freestyle.StrokeAttribute_getAttributeVec2f(*args)
+    def getAttributeVec3f(*args): return _Freestyle.StrokeAttribute_getAttributeVec3f(*args)
+    def isAttributeAvailableReal(*args): return _Freestyle.StrokeAttribute_isAttributeAvailableReal(*args)
+    def isAttributeAvailableVec2f(*args): return _Freestyle.StrokeAttribute_isAttributeAvailableVec2f(*args)
+    def isAttributeAvailableVec3f(*args): return _Freestyle.StrokeAttribute_isAttributeAvailableVec3f(*args)
+    def setColor(*args): return _Freestyle.StrokeAttribute_setColor(*args)
+    def setAlpha(*args): return _Freestyle.StrokeAttribute_setAlpha(*args)
+    def setThickness(*args): return _Freestyle.StrokeAttribute_setThickness(*args)
+    def setVisible(*args): return _Freestyle.StrokeAttribute_setVisible(*args)
+    def setAttributeReal(*args): return _Freestyle.StrokeAttribute_setAttributeReal(*args)
+    def setAttributeVec2f(*args): return _Freestyle.StrokeAttribute_setAttributeVec2f(*args)
+    def setAttributeVec3f(*args): return _Freestyle.StrokeAttribute_setAttributeVec3f(*args)
+StrokeAttribute_swigregister = _Freestyle.StrokeAttribute_swigregister
+StrokeAttribute_swigregister(StrokeAttribute)
+
+class StrokeVertex(CurvePoint):
+    __swig_setmethods__ = {}
+    for _s in [CurvePoint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, StrokeVertex, name, value)
+    __swig_getmethods__ = {}
+    for _s in [CurvePoint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, StrokeVertex, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.StrokeVertex_getExactTypeName(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_StrokeVertex(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_StrokeVertex
+    __del__ = lambda self : None;
+    def x(*args): return _Freestyle.StrokeVertex_x(*args)
+    def y(*args): return _Freestyle.StrokeVertex_y(*args)
+    def getPoint(*args): return _Freestyle.StrokeVertex_getPoint(*args)
+    def attribute(*args): return _Freestyle.StrokeVertex_attribute(*args)
+    def curvilinearAbscissa(*args): return _Freestyle.StrokeVertex_curvilinearAbscissa(*args)
+    def strokeLength(*args): return _Freestyle.StrokeVertex_strokeLength(*args)
+    def u(*args): return _Freestyle.StrokeVertex_u(*args)
+    def setX(*args): return _Freestyle.StrokeVertex_setX(*args)
+    def setY(*args): return _Freestyle.StrokeVertex_setY(*args)
+    def setPoint(*args): return _Freestyle.StrokeVertex_setPoint(*args)
+    def setAttribute(*args): return _Freestyle.StrokeVertex_setAttribute(*args)
+    def setCurvilinearAbscissa(*args): return _Freestyle.StrokeVertex_setCurvilinearAbscissa(*args)
+    def setStrokeLength(*args): return _Freestyle.StrokeVertex_setStrokeLength(*args)
+StrokeVertex_swigregister = _Freestyle.StrokeVertex_swigregister
+StrokeVertex_swigregister(StrokeVertex)
+
+class Stroke(Interface1D):
+    __swig_setmethods__ = {}
+    for _s in [Interface1D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Stroke, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Interface1D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Stroke, name)
+    __repr__ = _swig_repr
+    def getExactTypeName(*args): return _Freestyle.Stroke_getExactTypeName(*args)
+    def getId(*args): return _Freestyle.Stroke_getId(*args)
+    DRY_MEDIUM = _Freestyle.Stroke_DRY_MEDIUM
+    HUMID_MEDIUM = _Freestyle.Stroke_HUMID_MEDIUM
+    OPAQUE_MEDIUM = _Freestyle.Stroke_OPAQUE_MEDIUM
+    def __init__(self, *args): 
+        this = _Freestyle.new_Stroke(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Stroke
+    __del__ = lambda self : None;
+    def ComputeSampling(*args): return _Freestyle.Stroke_ComputeSampling(*args)
+    def Resample(*args): return _Freestyle.Stroke_Resample(*args)
+    def RemoveVertex(*args): return _Freestyle.Stroke_RemoveVertex(*args)
+    def InsertVertex(*args): return _Freestyle.Stroke_InsertVertex(*args)
+    def Render(*args): return _Freestyle.Stroke_Render(*args)
+    def RenderBasic(*args): return _Freestyle.Stroke_RenderBasic(*args)
+    def getLength2D(*args): return _Freestyle.Stroke_getLength2D(*args)
+    def getMediumType(*args): return _Freestyle.Stroke_getMediumType(*args)
+    def getTextureId(*args): return _Freestyle.Stroke_getTextureId(*args)
+    def hasTips(*args): return _Freestyle.Stroke_hasTips(*args)
+    def vertices_size(*args): return _Freestyle.Stroke_vertices_size(*args)
+    def viewedges_begin(*args): return _Freestyle.Stroke_viewedges_begin(*args)
+    def viewedges_end(*args): return _Freestyle.Stroke_viewedges_end(*args)
+    def viewedges_size(*args): return _Freestyle.Stroke_viewedges_size(*args)
+    def getBeginningOrientation(*args): return _Freestyle.Stroke_getBeginningOrientation(*args)
+    def getBeginningOrientationX(*args): return _Freestyle.Stroke_getBeginningOrientationX(*args)
+    def getBeginningOrientationY(*args): return _Freestyle.Stroke_getBeginningOrientationY(*args)
+    def getEndingOrientation(*args): return _Freestyle.Stroke_getEndingOrientation(*args)
+    def getEndingOrientationX(*args): return _Freestyle.Stroke_getEndingOrientationX(*args)
+    def getEndingOrientationY(*args): return _Freestyle.Stroke_getEndingOrientationY(*args)
+    def setId(*args): return _Freestyle.Stroke_setId(*args)
+    def setLength(*args): return _Freestyle.Stroke_setLength(*args)
+    def setMediumType(*args): return _Freestyle.Stroke_setMediumType(*args)
+    def setTextureId(*args): return _Freestyle.Stroke_setTextureId(*args)
+    def setTips(*args): return _Freestyle.Stroke_setTips(*args)
+    def push_back(*args): return _Freestyle.Stroke_push_back(*args)
+    def push_front(*args): return _Freestyle.Stroke_push_front(*args)
+    def AddViewEdge(*args): return _Freestyle.Stroke_AddViewEdge(*args)
+    def setBeginningOrientation(*args): return _Freestyle.Stroke_setBeginningOrientation(*args)
+    def setEndingOrientation(*args): return _Freestyle.Stroke_setEndingOrientation(*args)
+    def strokeVerticesBegin(*args): return _Freestyle.Stroke_strokeVerticesBegin(*args)
+    def strokeVerticesEnd(*args): return _Freestyle.Stroke_strokeVerticesEnd(*args)
+    def strokeVerticesSize(*args): return _Freestyle.Stroke_strokeVerticesSize(*args)
+    def verticesBegin(*args): return _Freestyle.Stroke_verticesBegin(*args)
+    def verticesEnd(*args): return _Freestyle.Stroke_verticesEnd(*args)
+    def pointsBegin(*args): return _Freestyle.Stroke_pointsBegin(*args)
+    def pointsEnd(*args): return _Freestyle.Stroke_pointsEnd(*args)
+Stroke_swigregister = _Freestyle.Stroke_swigregister
+Stroke_swigregister(Stroke)
+
+class ShadersContainer(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ShadersContainer, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ShadersContainer, name)
+    __repr__ = _swig_repr
+    def iterator(*args): return _Freestyle.ShadersContainer_iterator(*args)
+    def __iter__(self): return self.iterator()
+    def __nonzero__(*args): return _Freestyle.ShadersContainer___nonzero__(*args)
+    def __len__(*args): return _Freestyle.ShadersContainer___len__(*args)
+    def pop(*args): return _Freestyle.ShadersContainer_pop(*args)
+    def __getslice__(*args): return _Freestyle.ShadersContainer___getslice__(*args)
+    def __setslice__(*args): return _Freestyle.ShadersContainer___setslice__(*args)
+    def __delslice__(*args): return _Freestyle.ShadersContainer___delslice__(*args)
+    def __delitem__(*args): return _Freestyle.ShadersContainer___delitem__(*args)
+    def __getitem__(*args): return _Freestyle.ShadersContainer___getitem__(*args)
+    def __setitem__(*args): return _Freestyle.ShadersContainer___setitem__(*args)
+    def append(*args): return _Freestyle.ShadersContainer_append(*args)
+    def empty(*args): return _Freestyle.ShadersContainer_empty(*args)
+    def size(*args): return _Freestyle.ShadersContainer_size(*args)
+    def clear(*args): return _Freestyle.ShadersContainer_clear(*args)
+    def swap(*args): return _Freestyle.ShadersContainer_swap(*args)
+    def get_allocator(*args): return _Freestyle.ShadersContainer_get_allocator(*args)
+    def begin(*args): return _Freestyle.ShadersContainer_begin(*args)
+    def end(*args): return _Freestyle.ShadersContainer_end(*args)
+    def rbegin(*args): return _Freestyle.ShadersContainer_rbegin(*args)
+    def rend(*args): return _Freestyle.ShadersContainer_rend(*args)
+    def pop_back(*args): return _Freestyle.ShadersContainer_pop_back(*args)
+    def erase(*args): return _Freestyle.ShadersContainer_erase(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ShadersContainer(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def push_back(*args): return _Freestyle.ShadersContainer_push_back(*args)
+    def front(*args): return _Freestyle.ShadersContainer_front(*args)
+    def back(*args): return _Freestyle.ShadersContainer_back(*args)
+    def assign(*args): return _Freestyle.ShadersContainer_assign(*args)
+    def resize(*args): return _Freestyle.ShadersContainer_resize(*args)
+    def insert(*args): return _Freestyle.ShadersContainer_insert(*args)
+    def reserve(*args): return _Freestyle.ShadersContainer_reserve(*args)
+    def capacity(*args): return _Freestyle.ShadersContainer_capacity(*args)
+    __swig_destroy__ = _Freestyle.delete_ShadersContainer
+    __del__ = lambda self : None;
+ShadersContainer_swigregister = _Freestyle.ShadersContainer_swigregister
+ShadersContainer_swigregister(ShadersContainer)
+
+class StrokeShader(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, StrokeShader, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, StrokeShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        if self.__class__ == StrokeShader:
+            args = (None,) + args
+        else:
+            args = (self,) + args
+        this = _Freestyle.new_StrokeShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_StrokeShader
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.StrokeShader_getName(*args)
+    def shade(*args): return _Freestyle.StrokeShader_shade(*args)
+    def __disown__(self):
+        self.this.disown()
+        _Freestyle.disown_StrokeShader(self)
+        return weakref_proxy(self)
+StrokeShader_swigregister = _Freestyle.StrokeShader_swigregister
+StrokeShader_swigregister(StrokeShader)
+
+class ConstantThicknessShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantThicknessShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ConstantThicknessShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ConstantThicknessShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ConstantThicknessShader
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.ConstantThicknessShader_getName(*args)
+    def shade(*args): return _Freestyle.ConstantThicknessShader_shade(*args)
+ConstantThicknessShader_swigregister = _Freestyle.ConstantThicknessShader_swigregister
+ConstantThicknessShader_swigregister(ConstantThicknessShader)
+
+class ConstantExternThicknessShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantExternThicknessShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ConstantExternThicknessShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ConstantExternThicknessShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ConstantExternThicknessShader
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.ConstantExternThicknessShader_getName(*args)
+    def shade(*args): return _Freestyle.ConstantExternThicknessShader_shade(*args)
+ConstantExternThicknessShader_swigregister = _Freestyle.ConstantExternThicknessShader_swigregister
+ConstantExternThicknessShader_swigregister(ConstantExternThicknessShader)
+
+class IncreasingThicknessShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IncreasingThicknessShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, IncreasingThicknessShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_IncreasingThicknessShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_IncreasingThicknessShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.IncreasingThicknessShader_shade(*args)
+IncreasingThicknessShader_swigregister = _Freestyle.IncreasingThicknessShader_swigregister
+IncreasingThicknessShader_swigregister(IncreasingThicknessShader)
+
+class ConstrainedIncreasingThicknessShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstrainedIncreasingThicknessShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ConstrainedIncreasingThicknessShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ConstrainedIncreasingThicknessShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ConstrainedIncreasingThicknessShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.ConstrainedIncreasingThicknessShader_shade(*args)
+ConstrainedIncreasingThicknessShader_swigregister = _Freestyle.ConstrainedIncreasingThicknessShader_swigregister
+ConstrainedIncreasingThicknessShader_swigregister(ConstrainedIncreasingThicknessShader)
+
+class LengthDependingThicknessShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, LengthDependingThicknessShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, LengthDependingThicknessShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_LengthDependingThicknessShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_LengthDependingThicknessShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.LengthDependingThicknessShader_shade(*args)
+LengthDependingThicknessShader_swigregister = _Freestyle.LengthDependingThicknessShader_swigregister
+LengthDependingThicknessShader_swigregister(LengthDependingThicknessShader)
+
+class ThicknessVariationPatternShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ThicknessVariationPatternShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ThicknessVariationPatternShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ThicknessVariationPatternShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ThicknessVariationPatternShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.ThicknessVariationPatternShader_shade(*args)
+ThicknessVariationPatternShader_swigregister = _Freestyle.ThicknessVariationPatternShader_swigregister
+ThicknessVariationPatternShader_swigregister(ThicknessVariationPatternShader)
+
+class ThicknessNoiseShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ThicknessNoiseShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ThicknessNoiseShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ThicknessNoiseShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.ThicknessNoiseShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_ThicknessNoiseShader
+    __del__ = lambda self : None;
+ThicknessNoiseShader_swigregister = _Freestyle.ThicknessNoiseShader_swigregister
+ThicknessNoiseShader_swigregister(ThicknessNoiseShader)
+
+class ConstantColorShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantColorShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ConstantColorShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ConstantColorShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def getName(*args): return _Freestyle.ConstantColorShader_getName(*args)
+    def shade(*args): return _Freestyle.ConstantColorShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_ConstantColorShader
+    __del__ = lambda self : None;
+ConstantColorShader_swigregister = _Freestyle.ConstantColorShader_swigregister
+ConstantColorShader_swigregister(ConstantColorShader)
+
+class IncreasingColorShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, IncreasingColorShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, IncreasingColorShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_IncreasingColorShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.IncreasingColorShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_IncreasingColorShader
+    __del__ = lambda self : None;
+IncreasingColorShader_swigregister = _Freestyle.IncreasingColorShader_swigregister
+IncreasingColorShader_swigregister(IncreasingColorShader)
+
+class ColorVariationPatternShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ColorVariationPatternShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ColorVariationPatternShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ColorVariationPatternShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ColorVariationPatternShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.ColorVariationPatternShader_shade(*args)
+ColorVariationPatternShader_swigregister = _Freestyle.ColorVariationPatternShader_swigregister
+ColorVariationPatternShader_swigregister(ColorVariationPatternShader)
+
+class MaterialColorShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, MaterialColorShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, MaterialColorShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_MaterialColorShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.MaterialColorShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_MaterialColorShader
+    __del__ = lambda self : None;
+MaterialColorShader_swigregister = _Freestyle.MaterialColorShader_swigregister
+MaterialColorShader_swigregister(MaterialColorShader)
+
+class CalligraphicColorShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CalligraphicColorShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, CalligraphicColorShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_CalligraphicColorShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.CalligraphicColorShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_CalligraphicColorShader
+    __del__ = lambda self : None;
+CalligraphicColorShader_swigregister = _Freestyle.CalligraphicColorShader_swigregister
+CalligraphicColorShader_swigregister(CalligraphicColorShader)
+
+class ColorNoiseShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ColorNoiseShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ColorNoiseShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ColorNoiseShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.ColorNoiseShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_ColorNoiseShader
+    __del__ = lambda self : None;
+ColorNoiseShader_swigregister = _Freestyle.ColorNoiseShader_swigregister
+ColorNoiseShader_swigregister(ColorNoiseShader)
+
+class TextureAssignerShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TextureAssignerShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TextureAssignerShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_TextureAssignerShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.TextureAssignerShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_TextureAssignerShader
+    __del__ = lambda self : None;
+TextureAssignerShader_swigregister = _Freestyle.TextureAssignerShader_swigregister
+TextureAssignerShader_swigregister(TextureAssignerShader)
+
+class StrokeTextureShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, StrokeTextureShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, StrokeTextureShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_StrokeTextureShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.StrokeTextureShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_StrokeTextureShader
+    __del__ = lambda self : None;
+StrokeTextureShader_swigregister = _Freestyle.StrokeTextureShader_swigregister
+StrokeTextureShader_swigregister(StrokeTextureShader)
+
+class BackboneStretcherShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, BackboneStretcherShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, BackboneStretcherShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_BackboneStretcherShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.BackboneStretcherShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_BackboneStretcherShader
+    __del__ = lambda self : None;
+BackboneStretcherShader_swigregister = _Freestyle.BackboneStretcherShader_swigregister
+BackboneStretcherShader_swigregister(BackboneStretcherShader)
+
+class SamplingShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SamplingShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, SamplingShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_SamplingShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.SamplingShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_SamplingShader
+    __del__ = lambda self : None;
+SamplingShader_swigregister = _Freestyle.SamplingShader_swigregister
+SamplingShader_swigregister(SamplingShader)
+
+class ExternalContourStretcherShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ExternalContourStretcherShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, ExternalContourStretcherShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_ExternalContourStretcherShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.ExternalContourStretcherShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_ExternalContourStretcherShader
+    __del__ = lambda self : None;
+ExternalContourStretcherShader_swigregister = _Freestyle.ExternalContourStretcherShader_swigregister
+ExternalContourStretcherShader_swigregister(ExternalContourStretcherShader)
+
+class BSplineShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, BSplineShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, BSplineShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_BSplineShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.BSplineShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_BSplineShader
+    __del__ = lambda self : None;
+BSplineShader_swigregister = _Freestyle.BSplineShader_swigregister
+BSplineShader_swigregister(BSplineShader)
+
+class BezierCurveShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, BezierCurveShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, BezierCurveShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_BezierCurveShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.BezierCurveShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_BezierCurveShader
+    __del__ = lambda self : None;
+BezierCurveShader_swigregister = _Freestyle.BezierCurveShader_swigregister
+BezierCurveShader_swigregister(BezierCurveShader)
+
+class InflateShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, InflateShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, InflateShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_InflateShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.InflateShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_InflateShader
+    __del__ = lambda self : None;
+InflateShader_swigregister = _Freestyle.InflateShader_swigregister
+InflateShader_swigregister(InflateShader)
+
+class PolygonalizationShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, PolygonalizationShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, PolygonalizationShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_PolygonalizationShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.PolygonalizationShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_PolygonalizationShader
+    __del__ = lambda self : None;
+PolygonalizationShader_swigregister = _Freestyle.PolygonalizationShader_swigregister
+PolygonalizationShader_swigregister(PolygonalizationShader)
+
+class GuidingLinesShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, GuidingLinesShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, GuidingLinesShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_GuidingLinesShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    def shade(*args): return _Freestyle.GuidingLinesShader_shade(*args)
+    __swig_destroy__ = _Freestyle.delete_GuidingLinesShader
+    __del__ = lambda self : None;
+GuidingLinesShader_swigregister = _Freestyle.GuidingLinesShader_swigregister
+GuidingLinesShader_swigregister(GuidingLinesShader)
+
+class TipRemoverShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, TipRemoverShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, TipRemoverShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_TipRemoverShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_TipRemoverShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.TipRemoverShader_shade(*args)
+TipRemoverShader_swigregister = _Freestyle.TipRemoverShader_swigregister
+TipRemoverShader_swigregister(TipRemoverShader)
+
+class streamShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, streamShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, streamShader, name)
+    __repr__ = _swig_repr
+    __swig_destroy__ = _Freestyle.delete_streamShader
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.streamShader_getName(*args)
+    def shade(*args): return _Freestyle.streamShader_shade(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_streamShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+streamShader_swigregister = _Freestyle.streamShader_swigregister
+streamShader_swigregister(streamShader)
+
+class fstreamShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, fstreamShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, fstreamShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_fstreamShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_fstreamShader
+    __del__ = lambda self : None;
+    def getName(*args): return _Freestyle.fstreamShader_getName(*args)
+    def shade(*args): return _Freestyle.fstreamShader_shade(*args)
+fstreamShader_swigregister = _Freestyle.fstreamShader_swigregister
+fstreamShader_swigregister(fstreamShader)
+
+class CalligraphicShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, CalligraphicShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, CalligraphicShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_CalligraphicShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_CalligraphicShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.CalligraphicShader_shade(*args)
+CalligraphicShader_swigregister = _Freestyle.CalligraphicShader_swigregister
+CalligraphicShader_swigregister(CalligraphicShader)
+
+class SpatialNoiseShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SpatialNoiseShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, SpatialNoiseShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_SpatialNoiseShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_SpatialNoiseShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.SpatialNoiseShader_shade(*args)
+SpatialNoiseShader_swigregister = _Freestyle.SpatialNoiseShader_swigregister
+SpatialNoiseShader_swigregister(SpatialNoiseShader)
+
+class SmoothingShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, SmoothingShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, SmoothingShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_SmoothingShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_SmoothingShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.SmoothingShader_shade(*args)
+SmoothingShader_swigregister = _Freestyle.SmoothingShader_swigregister
+SmoothingShader_swigregister(SmoothingShader)
+
+class Smoother(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Smoother, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Smoother, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Smoother(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Smoother
+    __del__ = lambda self : None;
+    def smooth(*args): return _Freestyle.Smoother_smooth(*args)
+    def computeCurvature(*args): return _Freestyle.Smoother_computeCurvature(*args)
+Smoother_swigregister = _Freestyle.Smoother_swigregister
+Smoother_swigregister(Smoother)
+
+class Omitter(Smoother):
+    __swig_setmethods__ = {}
+    for _s in [Smoother]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Omitter, name, value)
+    __swig_getmethods__ = {}
+    for _s in [Smoother]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, Omitter, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_Omitter(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_Omitter
+    __del__ = lambda self : None;
+    def omit(*args): return _Freestyle.Omitter_omit(*args)
+Omitter_swigregister = _Freestyle.Omitter_swigregister
+Omitter_swigregister(Omitter)
+
+class OmissionShader(StrokeShader):
+    __swig_setmethods__ = {}
+    for _s in [StrokeShader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, OmissionShader, name, value)
+    __swig_getmethods__ = {}
+    for _s in [StrokeShader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, OmissionShader, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        this = _Freestyle.new_OmissionShader(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_OmissionShader
+    __del__ = lambda self : None;
+    def shade(*args): return _Freestyle.OmissionShader_shade(*args)
+OmissionShader_swigregister = _Freestyle.OmissionShader_swigregister
+OmissionShader_swigregister(OmissionShader)
+
+class Operators(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Operators, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Operators, name)
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr
+    __swig_getmethods__["select"] = lambda x: _Freestyle.Operators_select
+    if _newclass:select = staticmethod(_Freestyle.Operators_select)
+    __swig_getmethods__["chain"] = lambda x: _Freestyle.Operators_chain
+    if _newclass:chain = staticmethod(_Freestyle.Operators_chain)
+    __swig_getmethods__["bidirectionalChain"] = lambda x: _Freestyle.Operators_bidirectionalChain
+    if _newclass:bidirectionalChain = staticmethod(_Freestyle.Operators_bidirectionalChain)
+    __swig_getmethods__["sequentialSplit"] = lambda x: _Freestyle.Operators_sequentialSplit
+    if _newclass:sequentialSplit = staticmethod(_Freestyle.Operators_sequentialSplit)
+    __swig_getmethods__["recursiveSplit"] = lambda x: _Freestyle.Operators_recursiveSplit
+    if _newclass:recursiveSplit = staticmethod(_Freestyle.Operators_recursiveSplit)
+    __swig_getmethods__["sort"] = lambda x: _Freestyle.Operators_sort
+    if _newclass:sort = staticmethod(_Freestyle.Operators_sort)
+    __swig_getmethods__["create"] = lambda x: _Freestyle.Operators_create
+    if _newclass:create = staticmethod(_Freestyle.Operators_create)
+    __swig_getmethods__["getViewEdgeFromIndex"] = lambda x: _Freestyle.Operators_getViewEdgeFromIndex
+    if _newclass:getViewEdgeFromIndex = staticmethod(_Freestyle.Operators_getViewEdgeFromIndex)
+    __swig_getmethods__["getChainFromIndex"] = lambda x: _Freestyle.Operators_getChainFromIndex
+    if _newclass:getChainFromIndex = staticmethod(_Freestyle.Operators_getChainFromIndex)
+    __swig_getmethods__["getStrokeFromIndex"] = lambda x: _Freestyle.Operators_getStrokeFromIndex
+    if _newclass:getStrokeFromIndex = staticmethod(_Freestyle.Operators_getStrokeFromIndex)
+    __swig_getmethods__["getViewEdgesSize"] = lambda x: _Freestyle.Operators_getViewEdgesSize
+    if _newclass:getViewEdgesSize = staticmethod(_Freestyle.Operators_getViewEdgesSize)
+    __swig_getmethods__["getChainsSize"] = lambda x: _Freestyle.Operators_getChainsSize
+    if _newclass:getChainsSize = staticmethod(_Freestyle.Operators_getChainsSize)
+    __swig_getmethods__["getStrokesSize"] = lambda x: _Freestyle.Operators_getStrokesSize
+    if _newclass:getStrokesSize = staticmethod(_Freestyle.Operators_getStrokesSize)
+    __swig_destroy__ = _Freestyle.delete_Operators
+    __del__ = lambda self : None;
+Operators_swigregister = _Freestyle.Operators_swigregister
+Operators_swigregister(Operators)
+Operators_select = _Freestyle.Operators_select
+Operators_chain = _Freestyle.Operators_chain
+Operators_bidirectionalChain = _Freestyle.Operators_bidirectionalChain
+Operators_sequentialSplit = _Freestyle.Operators_sequentialSplit
+Operators_recursiveSplit = _Freestyle.Operators_recursiveSplit
+Operators_sort = _Freestyle.Operators_sort
+Operators_create = _Freestyle.Operators_create
+Operators_getViewEdgeFromIndex = _Freestyle.Operators_getViewEdgeFromIndex
+Operators_getChainFromIndex = _Freestyle.Operators_getChainFromIndex
+Operators_getStrokeFromIndex = _Freestyle.Operators_getStrokeFromIndex
+Operators_getViewEdgesSize = _Freestyle.Operators_getViewEdgesSize
+Operators_getChainsSize = _Freestyle.Operators_getChainsSize
+Operators_getStrokesSize = _Freestyle.Operators_getStrokesSize
+
+class ltstr(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, ltstr, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, ltstr, name)
+    __repr__ = _swig_repr
+    def __call__(*args): return _Freestyle.ltstr___call__(*args)
+    def __init__(self, *args): 
+        this = _Freestyle.new_ltstr(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _Freestyle.delete_ltstr
+    __del__ = lambda self : None;
+ltstr_swigregister = _Freestyle.ltstr_swigregister
+ltstr_swigregister(ltstr)
+
+class Canvas(_object):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, Canvas, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, Canvas, name)
+    def __init__(self): raise AttributeError, "No constructor defined"
+    __repr__ = _swig_repr
+    __swig_getmethods__["getInstance"] = lambda x: _Freestyle.Canvas_getInstance
+    if _newclass:getInstance = staticmethod(_Freestyle.Canvas_getInstance)
+    NB_STEERABLE_VIEWMAP = _Freestyle.Canvas_NB_STEERABLE_VIEWMAP
+    __swig_destroy__ = _Freestyle.delete_Canvas
+    __del__ = lambda self : None;
+    def preDraw(*args): return _Freestyle.Canvas_preDraw(*args)
+    def Draw(*args): return _Freestyle.Canvas_Draw(*args)
+    def postDraw(*args): return _Freestyle.Canvas_postDraw(*args)
+    def Render(*args): return _Freestyle.Canvas_Render(*args)
+    def RenderBasic(*args): return _Freestyle.Canvas_RenderBasic(*args)
+    def RenderStroke(*args): return _Freestyle.Canvas_RenderStroke(*args)
+    def init(*args): return _Freestyle.Canvas_init(*args)
+    def Clear(*args): return _Freestyle.Canvas_Clear(*args)
+    def Erase(*args): return _Freestyle.Canvas_Erase(*args)
+    def readColorPixels(*args): return _Freestyle.Canvas_readColorPixels(*args)
+    def readDepthPixels(*args): return _Freestyle.Canvas_readDepthPixels(*args)
+    def update(*args): return _Freestyle.Canvas_update(*args)
+    def isEmpty(*args): return _Freestyle.Canvas_isEmpty(*args)
+    def loadMap(*args): return _Freestyle.Canvas_loadMap(*args)
+    def readMapPixel(*args): return _Freestyle.Canvas_readMapPixel(*args)
+    def loadSteerableViewMap(*args): return _Freestyle.Canvas_loadSteerableViewMap(*args)
+    def getSteerableViewMap(*args): return _Freestyle.Canvas_getSteerableViewMap(*args)
+    def selectedFEdge(*args): return _Freestyle.Canvas_selectedFEdge(*args)
+    def width(*args): return _Freestyle.Canvas_width(*args)
+    def height(*args): return _Freestyle.Canvas_height(*args)
+    def currentPaperTextureIndex(*args): return _Freestyle.Canvas_currentPaperTextureIndex(*args)
+    def scene3DBBox(*args): return _Freestyle.Canvas_scene3DBBox(*args)
+    def renderer(*args): return _Freestyle.Canvas_renderer(*args)
+    def getCurrentStyleModule(*args): return _Freestyle.Canvas_getCurrentStyleModule(*args)
+    def getRecordFlag(*args): return _Freestyle.Canvas_getRecordFlag(*args)
+    def setSelectedFEdge(*args): return _Freestyle.Canvas_setSelectedFEdge(*args)
+    def InsertStyleModule(*args): return _Freestyle.Canvas_InsertStyleModule(*args)
+    def RemoveStyleModule(*args): return _Freestyle.Canvas_RemoveStyleModule(*args)
+    def SwapStyleModules(*args): return _Freestyle.Canvas_SwapStyleModules(*args)
+    def ReplaceStyleModule(*args): return _Freestyle.Canvas_ReplaceStyleModule(*args)
+    def setVisible(*args): return _Freestyle.Canvas_setVisible(*args)
+    def AddLayer(*args): return _Freestyle.Canvas_AddLayer(*args)
+    def setCurrentPaperTextureIndex(*args): return _Freestyle.Canvas_setCurrentPaperTextureIndex(*args)
+    def changePaperTexture(*args): return _Freestyle.Canvas_changePaperTexture(*args)
+    def togglePaperTexture(*args): return _Freestyle.Canvas_togglePaperTexture(*args)
+    def resetModified(*args): return _Freestyle.Canvas_resetModified(*args)
+    def causalStyleModules(*args): return _Freestyle.Canvas_causalStyleModules(*args)
+    def setModified(*args): return _Freestyle.Canvas_setModified(*args)
+Canvas_swigregister = _Freestyle.Canvas_swigregister
+Canvas_swigregister(Canvas)
+Canvas_getInstance = _Freestyle.Canvas_getInstance
+
+castToSVertex = _Freestyle.castToSVertex
+castToViewVertex = _Freestyle.castToViewVertex
+castToTVertex = _Freestyle.castToTVertex
+castToCurvePoint = _Freestyle.castToCurvePoint
+castToStrokeVertex = _Freestyle.castToStrokeVertex
+castToNonTVertex = _Freestyle.castToNonTVertex
+castToFEdge = _Freestyle.castToFEdge
+castToViewEdge = _Freestyle.castToViewEdge
+castToStroke = _Freestyle.castToStroke
+castToChain = _Freestyle.castToChain
+
+
diff --git a/source/blender/freestyle/style_modules/ChainingIterators.py b/source/blender/freestyle/style_modules/ChainingIterators.py
new file mode 100755
index 00000000000..60255c3d094
--- /dev/null
+++ b/source/blender/freestyle/style_modules/ChainingIterators.py
@@ -0,0 +1,731 @@
+#
+#  Filename : ChainingIterators.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Chaining Iterators to be used with chaining operators
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+
+## the natural chaining iterator
+## It follows the edges of same nature following the topology of
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+class pyChainSilhouetteIterator(ChainingIterator):
+	def __init__(self, stayInSelection=1):
+		ChainingIterator.__init__(self, stayInSelection, 1,None,1)
+	def getExactTypeName(self):
+		return "pyChainSilhouetteIterator"
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for i in range(len(natures)):
+				currentNature = self.getCurrentEdge().getNature()
+				if(natures[i] & currentNature):
+					count=0
+					while(it.isEnd() == 0):
+						visitNext = 0
+						oNature = it.getObject().getNature()
+						if(oNature & natures[i] != 0):
+							if(natures[i] != oNature):
+								for j in range(i):
+									if(natures[j] & oNature != 0):
+										visitNext = 1
+										break
+								if(visitNext != 0):
+									break	 
+							count = count+1
+							winner = it.getObject()
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		return winner
+
+## the natural chaining iterator
+## It follows the edges of same nature on the same
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+## You can specify whether to chain iterate over edges that were 
+## already visited or not.
+class pyChainSilhouetteGenericIterator(ChainingIterator):
+	def __init__(self, stayInSelection=1, stayInUnvisited=1):
+		ChainingIterator.__init__(self, stayInSelection, stayInUnvisited,None,1)
+	def getExactTypeName(self):
+		return "pyChainSilhouetteGenericIterator"
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for i in range(len(natures)):
+				currentNature = self.getCurrentEdge().getNature()
+				if(natures[i] & currentNature):
+					count=0
+					while(it.isEnd() == 0):
+						visitNext = 0
+						oNature = it.getObject().getNature()
+						ve = it.getObject()
+						if(ve.getId() == self.getCurrentEdge().getId()):
+							it.increment()
+							continue
+						if(oNature & natures[i] != 0):
+							if(natures[i] != oNature):
+								for j in range(i):
+									if(natures[j] & oNature != 0):
+										visitNext = 1
+										break
+								if(visitNext != 0):
+									break	 
+							count = count+1
+							winner = ve
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		return winner
+			
+class pyExternalContourChainingIterator(ChainingIterator):
+	def __init__(self):
+		ChainingIterator.__init__(self, 0, 1,None,1)
+		self._isExternalContour = ExternalContourUP1D()
+		
+	def getExactTypeName(self):
+		return "pyExternalContourIterator"
+	
+	def init(self):
+		self._nEdges = 0
+		self._isInSelection = 1
+
+	def checkViewEdge(self, ve, orientation):
+		if(orientation != 0):
+			vertex = ve.B()
+		else:
+			vertex = ve.A()
+		it = AdjacencyIterator(vertex,1,1)
+		while(it.isEnd() == 0):
+			ave = it.getObject()
+			if(self._isExternalContour(ave)):
+				return 1
+			it.increment()
+		print "pyExternlContourChainingIterator : didn't find next edge"
+		return 0
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		while(it.isEnd() == 0):
+			ve = it.getObject()
+			if(self._isExternalContour(ve)):
+				if (ve.getTimeStamp() == GetTimeStampCF()):
+					winner = ve
+			it.increment()
+		
+		self._nEdges = self._nEdges+1
+		if(winner == None):
+			orient = 1
+			it = AdjacencyIterator(iter)
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(it.isIncoming() != 0):
+					orient = 0
+				good = self.checkViewEdge(ve,orient)
+				if(good != 0):
+					winner = ve
+				it.increment()
+		return winner
+
+## the natural chaining iterator
+## with a sketchy multiple touch
+class pySketchyChainSilhouetteIterator(ChainingIterator):
+	def __init__(self, nRounds=3,stayInSelection=1):
+		ChainingIterator.__init__(self, stayInSelection, 0,None,1)
+		self._timeStamp = GetTimeStampCF()+nRounds
+		self._nRounds = nRounds
+	def getExactTypeName(self):
+		return "pySketchyChainSilhouetteIterator"
+	def init(self):
+		self._timeStamp = GetTimeStampCF()+self._nRounds
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for i in range(len(natures)):
+				currentNature = self.getCurrentEdge().getNature()
+				if(natures[i] & currentNature):
+					count=0
+					while(it.isEnd() == 0):
+						visitNext = 0
+						oNature = it.getObject().getNature()
+						ve = it.getObject()
+						if(ve.getId() == self.getCurrentEdge().getId()):
+							it.increment()
+							continue
+						if(oNature & natures[i] != 0):
+							if(natures[i] != oNature):
+								for j in range(i):
+									if(natures[j] & oNature != 0):
+										visitNext = 1
+										break
+								if(visitNext != 0):
+									break	 
+							count = count+1
+							winner = ve
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		if(winner == None):
+			winner = self.getCurrentEdge()
+		if(winner.getChainingTimeStamp() == self._timeStamp):
+			winner = None
+		return winner
+
+
+# Chaining iterator designed for sketchy style.
+# can chain several times the same ViewEdge
+# in order to produce multiple strokes per ViewEdge.
+class pySketchyChainingIterator(ChainingIterator):
+	def __init__(self, nRounds=3, stayInSelection=1):
+		ChainingIterator.__init__(self, stayInSelection, 0,None,1)
+		self._timeStamp = GetTimeStampCF()+nRounds
+		self._nRounds = nRounds
+	def getExactTypeName(self):
+		return "pySketchyChainingIterator"
+
+	def init(self):
+		self._timeStamp = GetTimeStampCF()+self._nRounds
+
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		while(it.isEnd() == 0):
+			ve = it.getObject()
+			if(ve.getId() == self.getCurrentEdge().getId()):
+				it.increment()
+				continue
+			winner = ve
+			it.increment()
+		if(winner == None):
+			winner = self.getCurrentEdge()
+		if(winner.getChainingTimeStamp() == self._timeStamp):
+			return None
+		return winner
+
+
+## Chaining iterator that fills small occlusions
+## 	percent
+##		The max length of the occluded part 
+##		expressed in % of the total chain length
+class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
+	def __init__(self, percent):
+		ChainingIterator.__init__(self, 0, 1,None,1)
+		self._length = 0
+		self._percent = float(percent)
+	def getExactTypeName(self):
+		return "pyFillOcclusionsChainingIterator"
+	def init(self):
+		# each time we're evaluating a chain length 
+		# we try to do it once. Thus we reinit 
+		# the chain length here:
+		self._length = 0
+	def traverse(self, iter):
+		winner = None
+		winnerOrientation = 0
+		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					if(it.isIncoming() == 0):
+						winnerOrientation = 1
+					else:
+						winnerOrientation = 0
+                                        break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for nat in natures:
+				if(self.getCurrentEdge().getNature() & nat != 0):
+					count=0
+					while(it.isEnd() == 0):
+						ve = it.getObject()
+						if(ve.getNature() & nat != 0):
+							count = count+1
+							winner = ve
+							if(it.isIncoming() == 0):
+								winnerOrientation = 1
+							else:
+								winnerOrientation = 0
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		if(winner != None):
+			# check whether this edge was part of the selection
+			if(winner.getTimeStamp() != GetTimeStampCF()):
+				#print "---", winner.getId().getFirst(), winner.getId().getSecond()
+				# if not, let's check whether it's short enough with
+				# respect to the chain made without staying in the selection
+				#------------------------------------------------------------
+				# Did we compute the prospective chain length already ?
+				if(self._length == 0):
+					#if not, let's do it
+					_it = pyChainSilhouetteGenericIterator(0,0)
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					_it.init()
+					while(_it.isEnd() == 0):
+						ve = _it.getObject()
+						#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+						self._length = self._length + ve.getLength2D()
+						_it.increment()
+						if(_it.isBegin() != 0):
+							break;
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					if(_it.isBegin() == 0):
+						_it.decrement()
+						while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+							ve = _it.getObject()
+							#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+							self._length = self._length + ve.getLength2D()
+							_it.decrement()
+
+				# let's do the comparison:
+				# nw let's compute the length of this connex non selected part:
+				connexl = 0
+				_cit = pyChainSilhouetteGenericIterator(0,0)
+				_cit.setBegin(winner)
+				_cit.setCurrentEdge(winner)
+				_cit.setOrientation(winnerOrientation)
+				_cit.init()
+				while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+					ve = _cit.getObject()
+					#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
+					connexl = connexl + ve.getLength2D()
+					_cit.increment()
+				if(connexl > self._percent * self._length):
+					winner = None
+		return winner
+
+## Chaining iterator that fills small occlusions
+## 	size
+##		The max length of the occluded part 
+##		expressed in pixels
+class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
+	def __init__(self, length):
+		ChainingIterator.__init__(self, 0, 1,None,1)
+		self._length = float(length)
+	def getExactTypeName(self):
+		return "pySmallFillOcclusionsChainingIterator"
+	def traverse(self, iter):
+		winner = None
+		winnerOrientation = 0
+		#print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					if(it.isIncoming() == 0):
+						winnerOrientation = 1
+					else:
+						winnerOrientation = 0
+                                        break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for nat in natures:
+				if(self.getCurrentEdge().getNature() & nat != 0):
+					count=0
+					while(it.isEnd() == 0):
+						ve = it.getObject()
+						if(ve.getNature() & nat != 0):
+							count = count+1
+							winner = ve
+							if(it.isIncoming() == 0):
+								winnerOrientation = 1
+							else:
+								winnerOrientation = 0
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		if(winner != None):
+			# check whether this edge was part of the selection
+			if(winner.getTimeStamp() != GetTimeStampCF()):
+				#print "---", winner.getId().getFirst(), winner.getId().getSecond()
+				# nw let's compute the length of this connex non selected part:
+				connexl = 0
+				_cit = pyChainSilhouetteGenericIterator(0,0)
+				_cit.setBegin(winner)
+				_cit.setCurrentEdge(winner)
+				_cit.setOrientation(winnerOrientation)
+				_cit.init()
+				while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+					ve = _cit.getObject()
+					#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
+					connexl = connexl + ve.getLength2D()
+					_cit.increment()
+				if(connexl > self._length):
+					winner = None
+		return winner
+
+
+## Chaining iterator that fills small occlusions
+## 	percent
+##		The max length of the occluded part 
+##		expressed in % of the total chain length
+class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
+	def __init__(self, percent, l):
+		ChainingIterator.__init__(self, 0, 1,None,1)
+		self._length = 0
+		self._absLength = l
+		self._percent = float(percent)
+	def getExactTypeName(self):
+		return "pyFillOcclusionsChainingIterator"
+	def init(self):
+		# each time we're evaluating a chain length 
+		# we try to do it once. Thus we reinit 
+		# the chain length here:
+		self._length = 0
+	def traverse(self, iter):
+		winner = None
+		winnerOrientation = 0
+		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					if(it.isIncoming() == 0):
+						winnerOrientation = 1
+					else:
+						winnerOrientation = 0
+                                        break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for nat in natures:
+				if(self.getCurrentEdge().getNature() & nat != 0):
+					count=0
+					while(it.isEnd() == 0):
+						ve = it.getObject()
+						if(ve.getNature() & nat != 0):
+							count = count+1
+							winner = ve
+							if(it.isIncoming() == 0):
+								winnerOrientation = 1
+							else:
+								winnerOrientation = 0
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		if(winner != None):
+			# check whether this edge was part of the selection
+			if(winner.getTimeStamp() != GetTimeStampCF()):
+				#print "---", winner.getId().getFirst(), winner.getId().getSecond()
+				# if not, let's check whether it's short enough with
+				# respect to the chain made without staying in the selection
+				#------------------------------------------------------------
+				# Did we compute the prospective chain length already ?
+				if(self._length == 0):
+					#if not, let's do it
+					_it = pyChainSilhouetteGenericIterator(0,0)
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					_it.init()
+					while(_it.isEnd() == 0):
+						ve = _it.getObject()
+						#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+						self._length = self._length + ve.getLength2D()
+						_it.increment()
+						if(_it.isBegin() != 0):
+							break;
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					if(_it.isBegin() == 0):
+						_it.decrement()
+						while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+							ve = _it.getObject()
+							#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+							self._length = self._length + ve.getLength2D()
+							_it.decrement()
+
+				# let's do the comparison:
+				# nw let's compute the length of this connex non selected part:
+				connexl = 0
+				_cit = pyChainSilhouetteGenericIterator(0,0)
+				_cit.setBegin(winner)
+				_cit.setCurrentEdge(winner)
+				_cit.setOrientation(winnerOrientation)
+				_cit.init()
+				while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+					ve = _cit.getObject()
+					#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
+					connexl = connexl + ve.getLength2D()
+					_cit.increment()
+				if((connexl > self._percent * self._length) or (connexl > self._absLength)):
+					winner = None
+		return winner
+
+## Chaining iterator that fills small occlusions without caring about the 
+## actual selection
+## 	percent
+##		The max length of the occluded part 
+##		expressed in % of the total chain length
+class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
+	def __init__(self, percent, l):
+		ChainingIterator.__init__(self, 0, 1,None,1)
+		self._length = 0
+		self._absLength = l
+		self._percent = float(percent)
+	def getExactTypeName(self):
+		return "pyFillOcclusionsChainingIterator"
+	def init(self):
+		# each time we're evaluating a chain length 
+		# we try to do it once. Thus we reinit 
+		# the chain length here:
+		self._length = 0
+	def traverse(self, iter):
+		winner = None
+		winnerOrientation = 0
+		print self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond()
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				if(ve.getId() == mateVE.getId() ):
+					winner = ve
+					if(it.isIncoming() == 0):
+						winnerOrientation = 1
+					else:
+						winnerOrientation = 0
+                                        break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for nat in natures:
+				if(self.getCurrentEdge().getNature() & nat != 0):
+					count=0
+					while(it.isEnd() == 0):
+						ve = it.getObject()
+						if(ve.getNature() & nat != 0):
+							count = count+1
+							winner = ve
+							if(it.isIncoming() == 0):
+								winnerOrientation = 1
+							else:
+								winnerOrientation = 0
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		if(winner != None):
+			# check whether this edge was part of the selection
+			if(winner.qi() != 0):
+				#print "---", winner.getId().getFirst(), winner.getId().getSecond()
+				# if not, let's check whether it's short enough with
+				# respect to the chain made without staying in the selection
+				#------------------------------------------------------------
+				# Did we compute the prospective chain length already ?
+				if(self._length == 0):
+					#if not, let's do it
+					_it = pyChainSilhouetteGenericIterator(0,0)
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					_it.init()
+					while(_it.isEnd() == 0):
+						ve = _it.getObject()
+						#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+						self._length = self._length + ve.getLength2D()
+						_it.increment()
+						if(_it.isBegin() != 0):
+							break;
+					_it.setBegin(winner)
+					_it.setCurrentEdge(winner)
+					_it.setOrientation(winnerOrientation)
+					if(_it.isBegin() == 0):
+						_it.decrement()
+						while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+							ve = _it.getObject()
+							#print "--------", ve.getId().getFirst(), ve.getId().getSecond()
+							self._length = self._length + ve.getLength2D()
+							_it.decrement()
+
+				# let's do the comparison:
+				# nw let's compute the length of this connex non selected part:
+				connexl = 0
+				_cit = pyChainSilhouetteGenericIterator(0,0)
+				_cit.setBegin(winner)
+				_cit.setCurrentEdge(winner)
+				_cit.setOrientation(winnerOrientation)
+				_cit.init()
+				while((_cit.isEnd() == 0) and (_cit.getObject().qi() != 0)):
+					ve = _cit.getObject()
+					#print "-------- --------", ve.getId().getFirst(), ve.getId().getSecond()
+					connexl = connexl + ve.getLength2D()
+					_cit.increment()
+				if((connexl > self._percent * self._length) or (connexl > self._absLength)):
+					winner = None
+		return winner
+
+
+## the natural chaining iterator
+## It follows the edges of same nature on the same
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+class pyNoIdChainSilhouetteIterator(ChainingIterator):
+	def __init__(self, stayInSelection=1):
+		ChainingIterator.__init__(self, stayInSelection, 1,None,1)
+	def getExactTypeName(self):
+		return "pyChainSilhouetteIterator"
+	def traverse(self, iter):
+		winner = None
+		it = AdjacencyIterator(iter)
+		nextVertex = self.getVertex()
+		if(nextVertex.getNature() & T_VERTEX != 0):
+			tvertex = nextVertex.castToTVertex()
+			mateVE = tvertex.mate(self.getCurrentEdge())
+			while(it.isEnd() == 0):
+				ve = it.getObject()
+				feB = self.getCurrentEdge().fedgeB()
+				feA = ve.fedgeA()
+				vB = feB.vertexB()
+				vA = feA.vertexA()
+				if vA.getId().getFirst() == vB.getId().getFirst():
+					winner = ve
+					break
+				feA = self.getCurrentEdge().fedgeA()
+				feB = ve.fedgeB()
+				vB = feB.vertexB()
+				vA = feA.vertexA()
+				if vA.getId().getFirst() == vB.getId().getFirst():
+					winner = ve
+					break
+				feA = self.getCurrentEdge().fedgeB()
+				feB = ve.fedgeB()
+				vB = feB.vertexB()
+				vA = feA.vertexB()
+				if vA.getId().getFirst() == vB.getId().getFirst():
+					winner = ve
+					break
+				feA = self.getCurrentEdge().fedgeA()
+				feB = ve.fedgeA()
+				vB = feB.vertexA()
+				vA = feA.vertexA()
+				if vA.getId().getFirst() == vB.getId().getFirst():
+					winner = ve
+					break
+				it.increment()
+		else:
+			## case of NonTVertex
+			natures = [SILHOUETTE,BORDER,CREASE,SUGGESTIVE_CONTOUR,VALLEY,RIDGE]
+			for i in range(len(natures)):
+				currentNature = self.getCurrentEdge().getNature()
+				if(natures[i] & currentNature):
+					count=0
+					while(it.isEnd() == 0):
+						visitNext = 0
+						oNature = it.getObject().getNature()
+						if(oNature & natures[i] != 0):
+							if(natures[i] != oNature):
+								for j in range(i):
+									if(natures[j] & oNature != 0):
+										visitNext = 1
+										break
+								if(visitNext != 0):
+									break	 
+							count = count+1
+							winner = it.getObject()
+						it.increment()
+					if(count != 1):
+						winner = None
+					break
+		return winner
+
diff --git a/source/blender/freestyle/style_modules/Functions0D.py b/source/blender/freestyle/style_modules/Functions0D.py
new file mode 100755
index 00000000000..c1ba591c789
--- /dev/null
+++ b/source/blender/freestyle/style_modules/Functions0D.py
@@ -0,0 +1,81 @@
+from Freestyle import *
+
+
+class pyInverseCurvature2DAngleF0D(UnaryFunction0DDouble):
+	def getName(self):
+		return "InverseCurvature2DAngleF0D"
+
+	def __call__(self, inter):
+		func = Curvature2DAngleF0D()
+		c = func(inter)
+		return (3.1415 - c)
+
+class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
+	def getName(self):
+		return "CurvilinearLengthF0D"
+
+	def __call__(self, inter):
+		i0d = inter.getObject()
+		s = i0d.getExactTypeName()
+		if (string.find(s, "CurvePoint") == -1):
+			print "CurvilinearLengthF0D: not implemented yet for %s" % (s)
+			return -1
+		cp = castToCurvePoint(i0d)
+		return cp.t2d()
+
+## estimate anisotropy of density
+class pyDensityAnisotropyF0D(UnaryFunction0DDouble):
+	def __init__(self,level):
+		UnaryFunction0DDouble.__init__(self)
+		self.IsoDensity = ReadCompleteViewMapPixelF0D(level)
+		self.d0Density = ReadSteerableViewMapPixelF0D(0, level)
+		self.d1Density = ReadSteerableViewMapPixelF0D(1, level)
+		self.d2Density = ReadSteerableViewMapPixelF0D(2, level)
+		self.d3Density = ReadSteerableViewMapPixelF0D(3, level)
+	def getName(self):
+		return "pyDensityAnisotropyF0D"
+	def __call__(self, inter):
+		c_iso = self.IsoDensity(inter) 
+		c_0 = self.d0Density(inter) 
+		c_1 = self.d1Density(inter) 
+		c_2 = self.d2Density(inter) 
+		c_3 = self.d3Density(inter) 
+		cMax = max( max(c_0,c_1), max(c_2,c_3))
+		cMin = min( min(c_0,c_1), min(c_2,c_3))
+		if ( c_iso == 0 ):
+			v = 0
+		else:
+			v = (cMax-cMin)/c_iso
+		return (v)
+
+## Returns the gradient vector for a pixel 
+## 	l
+##	  the level at which one wants to compute the gradient
+class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
+	def __init__(self, l):
+		UnaryFunction0DVec2f.__init__(self)
+		self._l = l
+		self._step = pow(2,self._l)
+	def getName(self):
+		return "pyViewMapGradientVectorF0D"
+	def __call__(self, iter):
+		p = iter.getObject().getPoint2D()
+		gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+		gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+		return Vec2f(gx, gy)
+
+class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
+	def __init__(self, l):
+		UnaryFunction0DDouble.__init__(self)
+		self._l = l
+		self._step = pow(2,self._l)
+	def getName(self):
+		return "pyViewMapGradientNormF0D"
+	def __call__(self, iter):
+		p = iter.getObject().getPoint2D()
+		gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+		gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+		grad = Vec2f(gx, gy)
+		return grad.norm()
+
+
diff --git a/source/blender/freestyle/style_modules/Functions1D.py b/source/blender/freestyle/style_modules/Functions1D.py
new file mode 100755
index 00000000000..e2505466aae
--- /dev/null
+++ b/source/blender/freestyle/style_modules/Functions1D.py
@@ -0,0 +1,45 @@
+from Freestyle import *
+from Functions0D import *
+import string 
+
+class pyGetInverseProjectedZF1D(UnaryFunction1DDouble):
+	def getName(self):
+		return "pyGetInverseProjectedZF1D"
+
+	def __call__(self, inter):
+		func = GetProjectedZF1D()
+		z = func(inter)
+		return (1.0 - z)
+
+class pyGetSquareInverseProjectedZF1D(UnaryFunction1DDouble):
+	def getName(self):
+		return "pyGetInverseProjectedZF1D"
+
+	def __call__(self, inter):
+		func = GetProjectedZF1D()
+		z = func(inter)
+		return (1.0 - z*z)
+
+class pyDensityAnisotropyF1D(UnaryFunction1DDouble):
+	def __init__(self,level,  integrationType=MEAN, sampling=2.0):
+		UnaryFunction1DDouble.__init__(self, integrationType)
+		self._func = pyDensityAnisotropyF0D(level)
+		self._integration = integrationType
+		self._sampling = sampling
+	def getName(self):
+		return "pyDensityAnisotropyF1D"
+	def __call__(self, inter):
+		v =  integrateDouble(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
+		return v
+
+class pyViewMapGradientNormF1D(UnaryFunction1DDouble):
+	def __init__(self,l, integrationType, sampling=2.0):
+		UnaryFunction1DDouble.__init__(self, integrationType)
+		self._func = pyViewMapGradientNormF0D(l)
+		self._integration = integrationType
+		self._sampling = sampling
+	def getName(self):
+		return "pyViewMapGradientNormF1D"
+	def __call__(self, inter):
+		v =  integrateDouble(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
+		return v
diff --git a/source/blender/freestyle/style_modules/PredicatesB1D.py b/source/blender/freestyle/style_modules/PredicatesB1D.py
new file mode 100755
index 00000000000..dfc895e8d9b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/PredicatesB1D.py
@@ -0,0 +1,70 @@
+from Freestyle import *
+from Functions1D import *
+from random import *
+
+class pyZBP1D(BinaryPredicate1D):
+	def getName(self):
+		return "pyZBP1D"
+
+ 	def __call__(self, i1, i2):
+		func = GetZF1D()
+		return (func(i1) > func(i2))
+
+class pyZDiscontinuityBP1D(BinaryPredicate1D):
+	def __init__(self, iType = MEAN):
+		BinaryPredicate1D.__init__(self)
+		self._GetZDiscontinuity = ZDiscontinuityF1D(iType)
+
+	def getName(self):
+		return "pyZDiscontinuityBP1D"
+
+ 	def __call__(self, i1, i2):
+		return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
+
+class pyLengthBP1D(BinaryPredicate1D):
+	def getName(self):
+		return "LengthBP1D"
+
+ 	def __call__(self, i1, i2):
+		return (i1.getLength2D() > i2.getLength2D())
+
+class pySilhouetteFirstBP1D(BinaryPredicate1D):
+	def getName(self):
+		return "SilhouetteFirstBP1D"
+
+ 	def __call__(self, inter1, inter2):
+		bpred = SameShapeIdBP1D()
+		if (bpred(inter1, inter2) != 1):
+			return 0
+		if (inter1.getNature() & SILHOUETTE):
+			return (inter2.getNature() & SILHOUETTE)
+		return (inter1.getNature() == inter2.getNature())
+
+class pyNatureBP1D(BinaryPredicate1D):
+	def getName(self):
+		return "NatureBP1D"
+
+ 	def __call__(self, inter1, inter2):
+		return (inter1.getNature() & inter2.getNature())
+
+class pyViewMapGradientNormBP1D(BinaryPredicate1D):
+	def __init__(self,l, sampling=2.0):
+		BinaryPredicate1D.__init__(self)
+		self._GetGradient = pyViewMapGradientNormF1D(l, MEAN)
+	def getName(self):
+		return "pyViewMapGradientNormBP1D"
+	def __call__(self, i1,i2):
+		print "compare gradient"
+		return (self._GetGradient(i1) > self._GetGradient(i2))
+
+class pyShuffleBP1D(BinaryPredicate1D):
+	def __init__(self):
+		BinaryPredicate1D.__init__(self)
+		seed(1)
+	def getName(self):
+		return "pyNearAndContourFirstBP1D"
+
+ 	def __call__(self, inter1, inter2):
+		r1 = uniform(0,1)
+		r2 = uniform(0,1)
+		return (r1<r2)
diff --git a/source/blender/freestyle/style_modules/PredicatesU0D.py b/source/blender/freestyle/style_modules/PredicatesU0D.py
new file mode 100755
index 00000000000..10c4b85a6cf
--- /dev/null
+++ b/source/blender/freestyle/style_modules/PredicatesU0D.py
@@ -0,0 +1,103 @@
+from Freestyle import *
+from Functions0D import *
+
+class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
+	def __init__(self,a):
+		UnaryPredicate0D.__init__(self)
+		self._a = a
+			
+	def getName(self):
+		return "HigherCurvature2DAngleUP0D"
+
+	def __call__(self, inter):
+		func = Curvature2DAngleF0D()
+		a = func(inter)
+		return ( a > self._a)
+
+class pyUEqualsUP0D(UnaryPredicate0D):
+	def __init__(self,u, w):
+		UnaryPredicate0D.__init__(self)
+		self._u = u
+		self._w = w
+			
+	def getName(self):
+		return "UEqualsUP0D"
+
+	def __call__(self, inter):
+		func = pyCurvilinearLengthF0D()
+		u = func(inter)
+		return ( ( u > (self._u-self._w) ) and ( u < (self._u+self._w) ) )
+
+class pyVertexNatureUP0D(UnaryPredicate0D):
+	def __init__(self,nature):
+		UnaryPredicate0D.__init__(self)
+		self._nature = nature
+			
+	def getName(self):
+		return "pyVertexNatureUP0D"
+
+	def __call__(self, inter):
+		v = inter.getObject()
+		nat = v.getNature()
+		if(nat & self._nature):
+			return 1;
+		return 0
+
+## check whether an Interface0DIterator
+## is a TVertex and is the one that is 
+## hidden (inferred from the context)
+class pyBackTVertexUP0D(UnaryPredicate0D):
+	def __init__(self):
+		UnaryPredicate0D.__init__(self)
+		self._getQI = QuantitativeInvisibilityF0D()
+	def getName(self):
+		return "pyBackTVertexUP0D"
+	def __call__(self, iter):
+		v = iter.getObject()
+		nat = v.getNature()
+		if(nat & T_VERTEX == 0):
+			return 0
+		next = iter
+		if(next.isEnd()):
+			return 0
+		if(self._getQI(next) != 0):
+			return 1
+		return 0
+
+class pyParameterUP0DGoodOne(UnaryPredicate0D):
+	def __init__(self,pmin,pmax):
+		UnaryPredicate0D.__init__(self)
+		self._m = pmin
+		self._M = pmax
+		#self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
+
+	def getName(self):
+		return "pyCurvilinearAbscissaHigherThanUP0D"
+
+	def __call__(self, inter):
+		#s = self.getCurvilinearAbscissa(inter)
+		u = inter.u()
+		#print u
+		return ((u>=self._m) and (u<=self._M))
+
+class pyParameterUP0D(UnaryPredicate0D):
+	def __init__(self,pmin,pmax):
+		UnaryPredicate0D.__init__(self)
+		self._m = pmin
+		self._M = pmax
+		#self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
+
+	def getName(self):
+		return "pyCurvilinearAbscissaHigherThanUP0D"
+
+	def __call__(self, inter):
+		func = Curvature2DAngleF0D()
+		c = func(inter)
+		b1 = (c>0.1)
+		#s = self.getCurvilinearAbscissa(inter)
+		u = inter.u()
+		#print u
+		b = ((u>=self._m) and (u<=self._M))
+		return b and b1
+
+
diff --git a/source/blender/freestyle/style_modules/PredicatesU1D.py b/source/blender/freestyle/style_modules/PredicatesU1D.py
new file mode 100755
index 00000000000..18e9686f9df
--- /dev/null
+++ b/source/blender/freestyle/style_modules/PredicatesU1D.py
@@ -0,0 +1,381 @@
+from Freestyle import *
+from Functions1D import *
+
+count = 0
+class pyNFirstUP1D(UnaryPredicate1D):
+	def __init__(self, n):
+		UnaryPredicate1D.__init__(self)
+		self.__n = n
+	def __call__(self, inter):
+		global count
+		count = count + 1
+		if count <= self.__n:
+			return 1
+		return 0
+
+class pyHigherLengthUP1D(UnaryPredicate1D):
+	def __init__(self,l):
+		UnaryPredicate1D.__init__(self)
+		self._l = l
+			
+	def getName(self):
+		return "HigherLengthUP1D"
+
+	def __call__(self, inter):
+		return (inter.getLength2D() > self._l)
+
+class pyNatureUP1D(UnaryPredicate1D):
+	def __init__(self,nature):
+		UnaryPredicate1D.__init__(self)
+		self._nature = nature
+		self._getNature = CurveNatureF1D()
+			
+	def getName(self):
+		return "pyNatureUP1D"
+
+	def __call__(self, inter):
+		if(self._getNature(inter) & self._nature):
+			return 1
+		return 0
+
+class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
+	def __init__(self,n,a):
+		UnaryPredicate1D.__init__(self)
+		self._n = n
+		self._a = a
+
+	def getName(self):
+		return "HigherNumberOfTurnsUP1D"
+
+	def __call__(self, inter):
+		count = 0
+		func = Curvature2DAngleF0D()
+		it = inter.verticesBegin()
+		while(it.isEnd() == 0):
+			if(func(it) > self._a):
+				count = count+1
+			if(count > self._n):
+				return 1
+			it.increment()
+		return 0
+
+class pyDensityUP1D(UnaryPredicate1D):
+	def __init__(self,wsize,threshold, integration = MEAN, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._wsize = wsize
+		self._threshold = threshold
+		self._integration = integration
+		self._func = DensityF1D(self._wsize, self._integration, sampling)
+			
+	def getName(self):
+		return "pyDensityUP1D"
+
+	def __call__(self, inter):
+		if(self._func(inter) < self._threshold):
+			return 1
+		return 0
+
+class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, level,integration = MEAN):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._level = level
+		self._integration = integration
+			
+	def getName(self):
+		return "pyLowSteerableViewMapDensityUP1D"
+
+	def __call__(self, inter):
+		func = GetSteerableViewMapDensityF1D(self._level, self._integration)
+		v = func(inter)
+		print v
+		if(v < self._threshold):
+			return 1
+		return 0
+
+class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, orientation, level,integration = MEAN):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._orientation = orientation
+		self._level = level
+		self._integration = integration
+			
+	def getName(self):
+		return "pyLowDirectionalViewMapDensityUP1D"
+
+	def __call__(self, inter):
+		func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
+		v = func(inter)
+		#print v
+		if(v < self._threshold):
+			return 1
+		return 0
+
+class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, level,integration = MEAN):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._level = level
+		self._integration = integration
+		self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)	
+	def getName(self):
+		return "pyHighSteerableViewMapDensityUP1D"
+
+	def __call__(self, inter):
+		
+		v = self._func(inter)
+		if(v > self._threshold):
+			return 1
+		return 0
+
+class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, orientation, level,integration = MEAN, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._orientation = orientation
+		self._level = level
+		self._integration = integration
+		self._sampling = sampling		
+	def getName(self):
+		return "pyLowDirectionalViewMapDensityUP1D"
+
+	def __call__(self, inter):
+		func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)
+		v = func(inter)
+		if(v > self._threshold):
+			return 1
+		return 0
+
+class pyHighViewMapDensityUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, level,integration = MEAN, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._level = level
+		self._integration = integration
+		self._sampling = sampling
+		self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling
+			
+	def getName(self):
+		return "pyHighViewMapDensityUP1D"
+
+	def __call__(self, inter):
+		#print "toto"
+		#print func.getName()
+		#print inter.getExactTypeName()
+		v= self._func(inter)
+		if(v > self._threshold):
+			return 1
+		return 0
+
+class pyDensityFunctorUP1D(UnaryPredicate1D):
+	def __init__(self,wsize,threshold, functor, funcmin=0.0, funcmax=1.0, integration = MEAN):
+		UnaryPredicate1D.__init__(self)
+		self._wsize = wsize
+		self._threshold = float(threshold)
+		self._functor = functor
+		self._funcmin = float(funcmin)
+		self._funcmax = float(funcmax)
+		self._integration = integration
+			
+	def getName(self):
+		return "pyDensityFunctorUP1D"
+
+	def __call__(self, inter):
+		func = DensityF1D(self._wsize, self._integration)
+		res = self._functor(inter)
+		k = (res-self._funcmin)/(self._funcmax-self._funcmin)
+		if(func(inter) < self._threshold*k):
+			return 1
+		return 0
+
+class pyZSmallerUP1D(UnaryPredicate1D):
+	def __init__(self,z, integration=MEAN):
+		UnaryPredicate1D.__init__(self)
+		self._z = z
+		self._integration = integration
+	def getName(self):
+		return "pyZSmallerUP1D"
+
+	def __call__(self, inter):
+		func = GetProjectedZF1D(self._integration)
+		if(func(inter) < self._z):
+			return 1
+		return 0
+
+class pyIsOccludedByUP1D(UnaryPredicate1D):
+	def __init__(self,id):
+		UnaryPredicate1D.__init__(self)
+		self._id = id
+	def getName(self):
+		return "pyIsOccludedByUP1D"
+	def __call__(self, inter):
+		func = GetShapeF1D()
+		shapes = func(inter)
+		for s in shapes:
+			if(s.getId() == self._id):
+				return 0
+		it = inter.verticesBegin()
+		itlast = inter.verticesEnd()
+		itlast.decrement()
+		v =  it.getObject()
+		vlast = itlast.getObject()
+		tvertex = v.castToTVertex()
+		if(tvertex != None):
+			#print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
+			eit = tvertex.edgesBegin()
+			while(eit.isEnd() == 0):
+				ve = eit.getObject().first
+				if(ve.shape_id() == self._id):
+					return 1
+				#print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
+				eit.increment()
+		tvertex = vlast.castToTVertex()
+		if(tvertex != None):
+			#print "TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]"
+			eit = tvertex.edgesBegin()
+			while(eit.isEnd() == 0):
+				ve = eit.getObject().first
+				if(ve.shape_id() == self._id):
+					return 1
+				#print "-------", ve.getId().getFirst(), "-", ve.getId().getSecond()
+				eit.increment()
+		return 0
+
+class pyIsInOccludersListUP1D(UnaryPredicate1D):
+	def __init__(self,id):
+		UnaryPredicate1D.__init__(self)
+		self._id = id
+	def getName(self):
+		return "pyIsInOccludersListUP1D"
+	def __call__(self, inter):
+		func = GetOccludersF1D()
+		occluders = func(inter)
+		for a in occluders:
+			if(a.getId() == self._id):
+				return 1
+		return 0
+
+class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
+	def __init__(self):
+		UnaryPredicate1D.__init__(self)
+		self.__func1 = GetOccludersF1D()
+		self.__func2 = GetShapeF1D()
+	def getName(self):
+		return "pyIsOccludedByItselfUP1D"
+	def __call__(self, inter):
+		lst1 = self.__func1(inter)
+		lst2 = self.__func2(inter)
+		for vs1 in lst1:
+			for vs2 in lst2:
+				if vs1.getId() == vs2.getId():
+					return 1
+		return 0
+
+class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
+	def __init__(self, idlist):
+		UnaryPredicate1D.__init__(self)
+		self._idlist = idlist
+		self.__func1 = GetOccludersF1D()
+	def getName(self):
+		return "pyIsOccludedByIdListUP1D"
+	def __call__(self, inter):
+		lst1 = self.__func1(inter)
+		for vs1 in lst1:
+			for id in self._idlist:
+				if vs1.getId() == id:
+					return 1
+		return 0
+
+class pyShapeIdListUP1D(UnaryPredicate1D):
+	def __init__(self,idlist):
+		UnaryPredicate1D.__init__(self)
+		self._idlist = idlist
+		self._funcs = []
+		for id in idlist :
+			self._funcs.append(ShapeUP1D(id.getFirst(), id.getSecond()))
+		
+	def getName(self):
+		return "pyShapeIdUP1D"
+	def __call__(self, inter):
+		for func in self._funcs :
+			if(func(inter) == 1) :
+				return 1
+		return 0
+
+## deprecated
+class pyShapeIdUP1D(UnaryPredicate1D):
+	def __init__(self,id):
+		UnaryPredicate1D.__init__(self)
+		self._id = id
+	def getName(self):
+		return "pyShapeIdUP1D"
+	def __call__(self, inter):
+		func = GetShapeF1D()
+		shapes = func(inter)
+		for a in shapes:
+			if(a.getId() == self._id):
+				return 1
+		return 0
+
+class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, level, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._l = threshold
+		self.func = pyDensityAnisotropyF1D(level, MEAN, sampling)
+	def getName(self):
+		return "pyHighDensityAnisotropyUP1D"
+	def __call__(self, inter):
+		return (self.func(inter) > self._l)
+
+class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
+	def __init__(self,threshold, l, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._threshold = threshold
+		self._GetGradient = pyViewMapGradientNormF1D(l, MEAN)
+	def getName(self):
+		return "pyHighViewMapGradientNormUP1D"
+	def __call__(self, inter):
+		gn = self._GetGradient(inter)
+		#print gn
+		return (gn > self._threshold)
+
+class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
+	def __init__(self,functor, sigmaMin,sigmaMax, lmin, lmax, tmin, tmax, integration = MEAN, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._functor = functor
+		self._sigmaMin = float(sigmaMin)
+		self._sigmaMax = float(sigmaMax)
+		self._lmin = float(lmin)
+		self._lmax = float(lmax)
+		self._tmin = tmin
+		self._tmax = tmax
+		self._integration = integration
+		self._sampling = sampling
+			
+	def getName(self):
+		return "pyDensityUP1D"
+
+	def __call__(self, inter):
+		sigma = (self._sigmaMax-self._sigmaMin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._sigmaMin
+		t = (self._tmax-self._tmin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._tmin
+		if(sigma<self._sigmaMin):
+			sigma = self._sigmaMin
+		self._func = DensityF1D(sigma, self._integration, self._sampling)
+		d = self._func(inter)
+		if(d<t):
+			return 1
+		return 0
+
+class pyClosedCurveUP1D(UnaryPredicate1D):
+	def __call__(self, inter):
+		it = inter.verticesBegin()
+		itlast = inter.verticesEnd()
+		itlast.decrement()	
+		vlast = itlast.getObject()
+		v = it.getObject()
+		print v.getId().getFirst(), v.getId().getSecond()
+		print vlast.getId().getFirst(), vlast.getId().getSecond()
+		if(v.getId() == vlast.getId()):
+			return 1
+		return 0
diff --git a/source/blender/freestyle/style_modules/anisotropic_diffusion.py b/source/blender/freestyle/style_modules/anisotropic_diffusion.py
new file mode 100755
index 00000000000..688554dc92e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/anisotropic_diffusion.py
@@ -0,0 +1,75 @@
+#
+#  Filename : anisotropic_diffusion.py
+#  Author   : Fredo Durand
+#  Date     : 12/08/2004
+#  Purpose  : Smoothes lines using an anisotropic diffusion scheme
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+from vector import *
+from PredicatesU0D import *
+from math import *
+
+## thickness modifiers
+
+normalInfo=Normal2DF0D()
+curvatureInfo=Curvature2DAngleF0D()
+
+def edgestopping(x, sigma): 
+	return exp(- x*x/(2*sigma*sigma))
+
+class pyDiffusion2Shader(StrokeShader):
+	def __init__(self, lambda1, nbIter):
+		StrokeShader.__init__(self)
+		self._lambda = lambda1
+		self._nbIter = nbIter
+	def getName(self):
+		return "pyDiffusionShader"
+	def shade(self, stroke):
+		for i in range (1, self._nbIter):
+			it = stroke.strokeVerticesBegin()
+			while it.isEnd() == 0:
+				v=it.getObject()
+				p1 = v.getPoint()
+				p2 = normalInfo(it.castToInterface0DIterator())*self._lambda*curvatureInfo(it.castToInterface0DIterator())
+				v.setPoint(p1+p2)
+				it.increment()
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select( upred )
+bpred = TrueBP1D();
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(upred) )
+shaders_list = 	[
+		ConstantThicknessShader(4),
+		StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, 0),
+		SamplingShader(2),
+		pyDiffusion2Shader(-0.03, 30), 
+		IncreasingColorShader(1.0,0.0,0.0,1, 0, 1, 0, 1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
+
+
+
diff --git a/source/blender/freestyle/style_modules/apriori_and_causal_density.py b/source/blender/freestyle/style_modules/apriori_and_causal_density.py
new file mode 100755
index 00000000000..e6bcf046bd0
--- /dev/null
+++ b/source/blender/freestyle/style_modules/apriori_and_causal_density.py
@@ -0,0 +1,45 @@
+#
+#  Filename : apriori_and_causal_density.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines with high a priori density and 
+#             subjects them to the causal density so as to avoid 
+#             cluttering
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3,4) ) )
+bpred = TrueBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3,4))
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		ConstantThicknessShader(2), 
+		ConstantColorShader(0.0, 0.0, 0.0,1)
+		]
+Operators.create(pyDensityUP1D(1,0.1, MEAN), shaders_list)
diff --git a/source/blender/freestyle/style_modules/apriori_density.py b/source/blender/freestyle/style_modules/apriori_density.py
new file mode 100755
index 00000000000..77d41e7d04b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/apriori_density.py
@@ -0,0 +1,43 @@
+#
+#  Filename : apriori_density.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines having a high a priori density
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.1,5)))
+bpred = TrueBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.0007,5))
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		ConstantThicknessShader(2), 
+		ConstantColorShader(0.0, 0.0, 0.0,1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/backbone_stretcher.py b/source/blender/freestyle/style_modules/backbone_stretcher.py
new file mode 100755
index 00000000000..db17f2574ff
--- /dev/null
+++ b/source/blender/freestyle/style_modules/backbone_stretcher.py
@@ -0,0 +1,36 @@
+#
+#  Filename : backbone_stretcher.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Stretches the geometry of visible lines
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [TextureAssignerShader(4), ConstantColorShader(0.5, 0.5, 0.5), BackboneStretcherShader(20)]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/blueprint_circles.py b/source/blender/freestyle/style_modules/blueprint_circles.py
new file mode 100755
index 00000000000..5eca00ff4ac
--- /dev/null
+++ b/source/blender/freestyle/style_modules/blueprint_circles.py
@@ -0,0 +1,46 @@
+#
+#  Filename : blueprint_circles.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using circular contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(ChainPredicateIterator(upred,bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+		ConstantThicknessShader(5),
+                pyBluePrintCirclesShader(3),
+		pyPerlinNoise1DShader(0.1, 15, 8),
+		TextureAssignerShader(4),
+		IncreasingColorShader(0.8, 0.8, 0.3, 0.4, 0.3, 0.3, 0.3, 0.1)
+               ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/blueprint_ellipses.py b/source/blender/freestyle/style_modules/blueprint_ellipses.py
new file mode 100755
index 00000000000..4e34310b3ca
--- /dev/null
+++ b/source/blender/freestyle/style_modules/blueprint_ellipses.py
@@ -0,0 +1,46 @@
+#
+#  Filename : blueprint_ellipses.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using elliptic contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(ChainPredicateIterator(upred,bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+		ConstantThicknessShader(5),
+                pyBluePrintEllipsesShader(3),
+		pyPerlinNoise1DShader(0.1, 10, 8),
+		TextureAssignerShader(4),
+		IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.3, 0.3, 0.3, 0.1)
+               ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/blueprint_squares.py b/source/blender/freestyle/style_modules/blueprint_squares.py
new file mode 100755
index 00000000000..926f882456f
--- /dev/null
+++ b/source/blender/freestyle/style_modules/blueprint_squares.py
@@ -0,0 +1,45 @@
+#  Filename : blueprint_squares.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using square contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(ChainPredicateIterator(upred,bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+		ConstantThicknessShader(8),
+                pyBluePrintSquaresShader(2, 20),
+		pyPerlinNoise1DShader(0.07, 10, 8),
+		TextureAssignerShader(4),
+		IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.6, 0.3, 0.3, 0.3),
+		ConstantThicknessShader(4)
+               ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/cartoon.py b/source/blender/freestyle/style_modules/cartoon.py
new file mode 100755
index 00000000000..0c49f854f7d
--- /dev/null
+++ b/source/blender/freestyle/style_modules/cartoon.py
@@ -0,0 +1,42 @@
+#
+#  Filename : cartoon.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws colored lines. The color is automatically 
+#             infered from each object's material in a cartoon-like
+#             fashion.
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		BezierCurveShader(3),
+		ConstantThicknessShader(4), 
+		pyMaterialColorShader(0.8)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/contour.py b/source/blender/freestyle/style_modules/contour.py
new file mode 100755
index 00000000000..b7c97064cae
--- /dev/null
+++ b/source/blender/freestyle/style_modules/contour.py
@@ -0,0 +1,42 @@
+#
+#  Filename : contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws each object's visible contour
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D() ) )
+bpred = SameShapeIdBP1D();
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list =	 [
+		ConstantThicknessShader(5.0),
+		IncreasingColorShader(0.8,0,0,1,0.1,0,0,1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/curvature2d.py b/source/blender/freestyle/style_modules/curvature2d.py
new file mode 100755
index 00000000000..587c53071d0
--- /dev/null
+++ b/source/blender/freestyle/style_modules/curvature2d.py
@@ -0,0 +1,60 @@
+#
+#  Filename : curvature2d.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The stroke points are colored in gray levels and depending
+#             on the 2d curvature value
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+class py2DCurvatureColorShader(StrokeShader):
+	def getName(self):
+		return "py2DCurvatureColorShader"
+
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		func = Curvature2DAngleF0D()
+		while it.isEnd() == 0:
+			it0D = it.castToInterface0DIterator()
+			sv = it.getObject()
+			att = sv.attribute()
+			c = func(it0D)
+			if (c<0):
+ 				print "negative 2D curvature"
+			color = 10.0 * c/3.1415
+			att.setColor(color,color,color);
+			it.increment()
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, 0),
+		ConstantThicknessShader(5),
+		py2DCurvatureColorShader()
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/external_contour.py b/source/blender/freestyle/style_modules/external_contour.py
new file mode 100755
index 00000000000..ae49e18981e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/external_contour.py
@@ -0,0 +1,43 @@
+#
+#  Filename : external_contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from ChainingIterators import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred )
+bpred = TrueBP1D();
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = 	[
+		ConstantThicknessShader(3),
+		ConstantColorShader(0.0, 0.0, 0.0,1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/external_contour_sketchy.py b/source/blender/freestyle/style_modules/external_contour_sketchy.py
new file mode 100755
index 00000000000..1c3ffe94e1b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/external_contour_sketchy.py
@@ -0,0 +1,48 @@
+#
+#  Filename : external_contour_sketchy.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene using a sketchy 
+#             chaining iterator (in particular each ViewEdge can be drawn 
+#             several times
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D()) 
+Operators.select(upred)
+Operators.bidirectionalChain(pySketchyChainingIterator(), NotUP1D(upred))
+shaders_list = 	[
+		SamplingShader(4),
+		SpatialNoiseShader(10, 150, 2, 1, 1), 
+		IncreasingThicknessShader(4, 10), 
+		SmoothingShader(400, 0.1, 0, 0.2, 0, 0, 0, 1),
+		IncreasingColorShader(1,0,0,1,0,1,0,1),
+		TextureAssignerShader(4)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/external_contour_smooth.py b/source/blender/freestyle/style_modules/external_contour_smooth.py
new file mode 100755
index 00000000000..59633a25063
--- /dev/null
+++ b/source/blender/freestyle/style_modules/external_contour_smooth.py
@@ -0,0 +1,44 @@
+#
+#  Filename : external_contour_smooth.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws a smooth external contour
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+from ChainingIterators import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D();
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = 	[
+		SamplingShader(2),
+		IncreasingThicknessShader(4,20), 
+		IncreasingColorShader(1.0, 0.0, 0.5,1, 0.5,1, 0.3, 1),
+		SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/extra-lines.sml b/source/blender/freestyle/style_modules/extra-lines.sml
new file mode 100755
index 00000000000..c63cd40945d
--- /dev/null
+++ b/source/blender/freestyle/style_modules/extra-lines.sml
@@ -0,0 +1,3 @@
+1suggestive.py
+1ridges.py
+1nor_suggestive_or_ridges.py
diff --git a/source/blender/freestyle/style_modules/haloing.py b/source/blender/freestyle/style_modules/haloing.py
new file mode 100755
index 00000000000..b64b2d967f7
--- /dev/null
+++ b/source/blender/freestyle/style_modules/haloing.py
@@ -0,0 +1,50 @@
+#
+#  Filename : haloing.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : This style module selects the lines that 
+#             are connected (in the image) to a specific 
+#             object and trims them in order to produce
+#             a haloing effect around the target shape
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesB1D import *
+from shaders import *
+
+# id corresponds to the id of the target object 
+# (accessed by SHIFT+click)
+id = Id(3,0)
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0) , pyIsOccludedByUP1D(id))
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		IncreasingThicknessShader(3, 5), 
+		IncreasingColorShader(1,0,0, 1,0,1,0,1),
+		SamplingShader(1.0),
+		pyTVertexRemoverShader(),
+		TipRemoverShader(3.0)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/ignore_small_occlusions.py b/source/blender/freestyle/style_modules/ignore_small_occlusions.py
new file mode 100755
index 00000000000..98c318a3757
--- /dev/null
+++ b/source/blender/freestyle/style_modules/ignore_small_occlusions.py
@@ -0,0 +1,41 @@
+#
+#  Filename : ignore_small_oclusions.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The strokes are drawn through small occlusions
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+#Operators.bidirectionalChain(pyFillOcclusionsChainingIterator(0.1))
+Operators.bidirectionalChain(pyFillOcclusionsAbsoluteChainingIterator(12))
+shaders_list = 	[
+		SamplingShader(5.0),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0.0,0.0,0.0),
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/invisible_lines.py b/source/blender/freestyle/style_modules/invisible_lines.py
new file mode 100755
index 00000000000..5cce741e91e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/invisible_lines.py
@@ -0,0 +1,42 @@
+#
+#  Filename : invisible_lines.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws all lines whose Quantitative Invisibility 
+#             is different from 0
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+upred = NotUP1D(QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		SamplingShader(5.0),
+		ConstantThicknessShader(3.0), 
+		ConstantColorShader(0.7,0.7,0.7)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/japanese_bigbrush.py b/source/blender/freestyle/style_modules/japanese_bigbrush.py
new file mode 100755
index 00000000000..e0985497e2c
--- /dev/null
+++ b/source/blender/freestyle/style_modules/japanese_bigbrush.py
@@ -0,0 +1,59 @@
+#
+#  Filename : japanese_bigbrush.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Simulates a big brush fr oriental painting
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesB1D import *
+from Functions0D import *
+from shaders import *
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
+## Splits strokes at points of highest 2D curavture 
+## when there are too many abrupt turns in it
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursiveSplit(func,  pyParameterUP0D(0.2,0.8), NotUP1D(pyHigherNumberOfTurnsUP1D(3, 0.5)), 2)
+## Keeps only long enough strokes
+Operators.select(pyHigherLengthUP1D(100))
+## Sorts so as to draw the longest strokes first
+## (this will be done using the causal density)
+Operators.sort(pyLengthBP1D())
+shaders_list = 	[
+		pySamplingShader(10),
+		BezierCurveShader(30),
+		SamplingShader(50),
+		pyNonLinearVaryingThicknessShader(4,25, 0.6),
+		TextureAssignerShader(6),
+		ConstantColorShader(0.2, 0.2, 0.2,1.0),
+		TipRemoverShader(10)
+		]
+## Use the causal density to avoid cluttering
+Operators.create(pyDensityUP1D(8,0.4, MEAN), shaders_list)
+
+
diff --git a/source/blender/freestyle/style_modules/logical_operators.py b/source/blender/freestyle/style_modules/logical_operators.py
new file mode 100755
index 00000000000..63a0a9f9ed8
--- /dev/null
+++ b/source/blender/freestyle/style_modules/logical_operators.py
@@ -0,0 +1,36 @@
+from Freestyle import *
+
+class AndUP1D(UnaryPredicate1D):
+    def __init__(self, pred1, pred2):
+        UnaryPredicate1D.__init__(self)
+        self.__pred1 = pred1
+        self.__pred2 = pred2
+
+    def getName(self):
+        return "AndUP1D"
+
+    def __call__(self, inter):
+        return self.__pred1(inter) and self.__pred2(inter)
+    
+class OrUP1D(UnaryPredicate1D):
+    def __init__(self, pred1, pred2):
+        UnaryPredicate1D.__init__(self)
+        self.__pred1 = pred1
+        self.__pred2 = pred2
+
+    def getName(self):
+        return "OrUP1D"
+
+    def __call__(self, inter):
+        return self.__pred1(inter) or self.__pred2(inter)
+
+class NotUP1D(UnaryPredicate1D):
+	def __init__(self, pred):
+		UnaryPredicate1D.__init__(self)
+		self.__pred = pred
+
+	def getName(self):
+ 		return "NotUP1D"
+
+	def __call__(self, inter):
+		return self.__pred(inter) == 0
diff --git a/source/blender/freestyle/style_modules/long_anisotropically_dense.py b/source/blender/freestyle/style_modules/long_anisotropically_dense.py
new file mode 100755
index 00000000000..4bfeedf257f
--- /dev/null
+++ b/source/blender/freestyle/style_modules/long_anisotropically_dense.py
@@ -0,0 +1,81 @@
+#
+#  Filename : long_anisotropically_dense.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines that are long and have a high anisotropic 
+#             a priori density and uses causal density 
+#             to draw without cluttering. Ideally, half of the
+#             selected lines are culled using the causal density.
+#
+#             ********************* WARNING *************************************
+#             ******** The Directional a priori density maps must          ****** 
+#             ******** have been computed prior to using this style module ******
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesU0D import *
+from PredicatesB1D import *
+from Functions0D import *
+from Functions1D import *
+from shaders import *
+
+## custom density predicate
+class pyDensityUP1D(UnaryPredicate1D):
+	def __init__(self,wsize,threshold, integration = MEAN, sampling=2.0):
+ 		UnaryPredicate1D.__init__(self)
+		self._wsize = wsize
+		self._threshold = threshold
+		self._integration = integration
+		self._func = DensityF1D(self._wsize, self._integration, sampling)
+		self._func2 = DensityF1D(self._wsize, MAX, sampling)
+   
+	def getName(self):
+		return "pyDensityUP1D"
+
+	def __call__(self, inter):
+		c = self._func(inter)
+		m = self._func2(inter)
+		if(c < self._threshold):
+			return 1
+		if( m > 4* c ):
+			if ( c < 1.5*self._threshold ):
+				return 1
+		return 0
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
+Operators.select(pyHigherLengthUP1D(40))
+## selects lines having a high anisotropic a priori density
+Operators.select(pyHighDensityAnisotropyUP1D(0.3,4))
+Operators.sort(pyLengthBP1D())
+shaders_list =  [
+	SamplingShader(2.0),
+	ConstantThicknessShader(2),
+	ConstantColorShader(0.2,0.2,0.25,1), 
+			]
+## uniform culling
+Operators.create(pyDensityUP1D(3.0,2.0e-2, MEAN, 0.1), shaders_list)
+
+ 
diff --git a/source/blender/freestyle/style_modules/multiple_parameterization.py b/source/blender/freestyle/style_modules/multiple_parameterization.py
new file mode 100755
index 00000000000..ff04c5930c5
--- /dev/null
+++ b/source/blender/freestyle/style_modules/multiple_parameterization.py
@@ -0,0 +1,51 @@
+#
+#  Filename : multiple_parameterization.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The thickness and the color of the strokes vary continuously 
+#             independently from occlusions although only
+#             visible lines are actually drawn. This is equivalent
+#             to assigning the thickness using a parameterization covering
+#             the complete silhouette (visible+invisible) and drawing
+#             the strokes using a second parameterization that only
+#             covers the visible portions.
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+## Chain following the same nature, but without the restriction
+## of staying inside the selection (0).
+Operators.bidirectionalChain(ChainSilhouetteIterator(0))
+shaders_list = 	[
+		SamplingShader(20),
+		IncreasingThicknessShader(1.5, 30), 
+		ConstantColorShader(0.0,0.0,0.0),
+		IncreasingColorShader(1,0,0,1,0,1,0,1),
+		TextureAssignerShader(-1),
+		pyHLRShader() ## this shader draws only visible portions
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/nature.py b/source/blender/freestyle/style_modules/nature.py
new file mode 100755
index 00000000000..8cfd480ba3b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/nature.py
@@ -0,0 +1,43 @@
+#
+#  Filename : nature.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Uses the NatureUP1D predicate to select the lines
+#             of a given type (among SILHOUETTE, CREASE, SUGGESTIVE_CONTOURS,
+#             BORDERS).
+#             The suggestive contours must have been enabled in the 
+#             options dialog to appear in the View Map.
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(pyNatureUP1D(SILHOUETTE))
+Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D( pyNatureUP1D( SILHOUETTE) ) )
+shaders_list = 	[
+		IncreasingThicknessShader(3, 10), 
+		IncreasingColorShader(0.0,0.0,0.0, 1, 0.8,0,0,1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/near_lines.py b/source/blender/freestyle/style_modules/near_lines.py
new file mode 100755
index 00000000000..b132f6b5802
--- /dev/null
+++ b/source/blender/freestyle/style_modules/near_lines.py
@@ -0,0 +1,44 @@
+#
+#  Filename : near_lines.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the lines that are "closer" than a threshold 
+#             (between 0 and 1)
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyZSmallerUP1D(0.5, MEAN)) 
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		TextureAssignerShader(-1),
+		ConstantThicknessShader(5), 
+		ConstantColorShader(0.0, 0.0, 0.0)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/occluded_by_specific_object.py b/source/blender/freestyle/style_modules/occluded_by_specific_object.py
new file mode 100755
index 00000000000..96f431c2c4e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/occluded_by_specific_object.py
@@ -0,0 +1,45 @@
+#
+#  Filename : occluded_by_specific_object.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws only the lines that are occluded by a given object
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from shaders import *
+
+## the id of the occluder (use SHIFT+click on the ViewMap to
+## retrieve ids)
+id = Id(3,0)
+upred = AndUP1D(NotUP1D(QuantitativeInvisibilityUP1D(0)),
+pyIsInOccludersListUP1D(id))
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		SamplingShader(5),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0.3,0.3,0.3,1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/polygonalize.py b/source/blender/freestyle/style_modules/polygonalize.py
new file mode 100755
index 00000000000..81d47178404
--- /dev/null
+++ b/source/blender/freestyle/style_modules/polygonalize.py
@@ -0,0 +1,40 @@
+#
+#  Filename : polygonalize.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Make the strokes more "polygonal"
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		SamplingShader(2.0),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0.0,0.0,0.0),
+		PolygonalizationShader(8)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/qi0.py b/source/blender/freestyle/style_modules/qi0.py
new file mode 100755
index 00000000000..f742b777738
--- /dev/null
+++ b/source/blender/freestyle/style_modules/qi0.py
@@ -0,0 +1,41 @@
+#
+#  Filename : qi0.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             (most basic style module)
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		SamplingShader(5.0),
+		ConstantThicknessShader(4.0), 
+		ConstantColorShader(0.0,0.0,0.0)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/qi0_not_external_contour.py b/source/blender/freestyle/style_modules/qi0_not_external_contour.py
new file mode 100755
index 00000000000..047ab7e1a8e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/qi0_not_external_contour.py
@@ -0,0 +1,43 @@
+#
+#  Filename : qi0_not_external_contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             that do not belong to the external contour of the scene
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		SamplingShader(4),
+		SpatialNoiseShader(4, 150, 2, 1, 1), 
+		IncreasingThicknessShader(2, 5), 
+		BackboneStretcherShader(20),
+		IncreasingColorShader(1,0,0,1,0,1,0,1),
+		TextureAssignerShader(4)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/qi1.py b/source/blender/freestyle/style_modules/qi1.py
new file mode 100755
index 00000000000..234d196f15e
--- /dev/null
+++ b/source/blender/freestyle/style_modules/qi1.py
@@ -0,0 +1,42 @@
+#
+#  Filename : qi1.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines hidden by one surface.
+#             *** Quantitative Invisibility must have been 
+#             enabled in the options dialog to use this style module ****
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(1))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(1)))
+shaders_list = 	[
+		SamplingShader(5.0),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0.5,0.5,0.5, 1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/qi2.py b/source/blender/freestyle/style_modules/qi2.py
new file mode 100755
index 00000000000..8e45914c619
--- /dev/null
+++ b/source/blender/freestyle/style_modules/qi2.py
@@ -0,0 +1,42 @@
+#
+#  Filename : qi2.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines hidden by two surfaces.
+#             *** Quantitative Invisibility must have been 
+#             enabled in the options dialog to use this style module ****
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(2))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(2)))
+shaders_list = 	[
+		SamplingShader(10),
+		ConstantThicknessShader(1.5), 
+		ConstantColorShader(0.7,0.7,0.7, 1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/sequentialsplit_sketchy.py b/source/blender/freestyle/style_modules/sequentialsplit_sketchy.py
new file mode 100755
index 00000000000..b33cd5d4043
--- /dev/null
+++ b/source/blender/freestyle/style_modules/sequentialsplit_sketchy.py
@@ -0,0 +1,68 @@
+#
+#  Filename : sequentialsplit_sketchy.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Use the sequential split with two different
+#             predicates to specify respectively the starting and
+#             the stopping extremities for strokes 
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesU0D import *
+from Functions0D import *
+
+## Predicate to tell whether a TVertex
+## corresponds to a change from 0 to 1 or not.
+class pyBackTVertexUP0D(UnaryPredicate0D):
+	def __init__(self):
+		UnaryPredicate0D.__init__(self)
+		self._getQI = QuantitativeInvisibilityF0D()
+	def getName(self):
+		return "pyBackTVertexUP0D"
+	def __call__(self, iter):
+		v = iter.getObject()
+		nat = v.getNature()
+		if(nat & T_VERTEX == 0):
+			return 0
+		if(self._getQI(iter) != 0):
+			return 1
+		return 0
+
+
+upred = QuantitativeInvisibilityUP1D(0)
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+## starting and stopping predicates:
+start = pyVertexNatureUP0D(NON_T_VERTEX)
+stop = pyBackTVertexUP0D()
+Operators.sequentialSplit(start, stop, 10)
+shaders_list = [
+		SpatialNoiseShader(7, 120, 2, 1, 1), 
+		IncreasingThicknessShader(5, 8), 
+		ConstantColorShader(0.2, 0.2, 0.2, 1), 
+		TextureAssignerShader(4)
+		]
+Operators.create(TrueUP1D(), shaders_list)
+
diff --git a/source/blender/freestyle/style_modules/shaders.py b/source/blender/freestyle/style_modules/shaders.py
new file mode 100755
index 00000000000..208dfe91bb6
--- /dev/null
+++ b/source/blender/freestyle/style_modules/shaders.py
@@ -0,0 +1,1288 @@
+from Freestyle import *
+from PredicatesU0D import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from logical_operators import *
+from ChainingIterators import *
+from random import *
+from math import *
+from vector import *
+
+## thickness modifiers
+######################
+
+class pyDepthDiscontinuityThicknessShader(StrokeShader):
+	def __init__(self, min, max):
+		StrokeShader.__init__(self)
+		self.__min = float(min)
+		self.__max = float(max)
+		self.__func = ZDiscontinuityF0D()
+	def getName(self):
+		return "pyDepthDiscontinuityThicknessShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		z_min=0.0
+		z_max=1.0
+		a = (self.__max - self.__min)/(z_max-z_min)
+		b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			z = self.__func(it.castToInterface0DIterator())
+			thickness = a*z+b
+			it.getObject().attribute().setThickness(thickness, thickness)
+			it.increment()
+
+class pyConstantThicknessShader(StrokeShader):
+	def __init__(self, thickness):
+		StrokeShader.__init__(self)
+		self._thickness = thickness
+
+	def getName(self):
+		return "pyConstantThicknessShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			t = self._thickness/2.0
+			att.setThickness(t, t)
+			it.increment()
+
+class pyFXSThicknessShader(StrokeShader):
+	def __init__(self, thickness):
+		StrokeShader.__init__(self)
+		self._thickness = thickness
+
+	def getName(self):
+		return "pyFXSThicknessShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			t = self._thickness/2.0
+			att.setThickness(t, t)
+			it.increment()
+
+class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
+	def __init__(self, wsize, threshold_min, threshold_max, thicknessMin, thicknessMax):
+		StrokeShader.__init__(self)
+		self.wsize= wsize
+		self.threshold_min= threshold_min
+		self.threshold_max= threshold_max
+		self._thicknessMin = thicknessMin
+		self._thicknessMax = thicknessMax
+
+	def getName(self):
+		return "pyVaryingThicknessWithDensityShader"
+	def shade(self, stroke):
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		func = DensityF0D(self.wsize)
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			toto = it.castToInterface0DIterator()
+			c= func(toto)
+			if (c < self.threshold_min ):
+				c = self.threshold_min
+			if (c > self.threshold_max ):
+				c = self.threshold_max
+##			t = (c - self.threshold_min)/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
+			t = (self.threshold_max - c  )/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
+			att.setThickness(t/2.0, t/2.0)
+			i = i+1
+			it.increment()
+class pyIncreasingThicknessShader(StrokeShader):
+	def __init__(self, thicknessMin, thicknessMax):
+		StrokeShader.__init__(self)
+		self._thicknessMin = thicknessMin
+		self._thicknessMax = thicknessMax
+
+	def getName(self):
+		return "pyIncreasingThicknessShader"
+	def shade(self, stroke):
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			c = float(i)/float(n)
+			if(i < float(n)/2.0):
+				t = (1.0 - c)*self._thicknessMin + c * self._thicknessMax
+			else:
+				t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
+			att.setThickness(t/2.0, t/2.0)
+			i = i+1
+			it.increment()
+
+class pyConstrainedIncreasingThicknessShader(StrokeShader):
+	def __init__(self, thicknessMin, thicknessMax, ratio):
+		StrokeShader.__init__(self)
+		self._thicknessMin = thicknessMin
+		self._thicknessMax = thicknessMax
+		self._ratio = ratio
+
+	def getName(self):
+		return "pyConstrainedIncreasingThicknessShader"
+	def shade(self, stroke):
+		slength = stroke.getLength2D()
+		tmp = self._ratio*slength
+		maxT = 0.0
+		if(tmp < self._thicknessMax):
+			maxT = tmp
+		else:
+			maxT = self._thicknessMax
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			c = float(i)/float(n)
+			if(i < float(n)/2.0):
+				t = (1.0 - c)*self._thicknessMin + c * maxT
+			else:
+				t = (1.0 - c)*maxT + c * self._thicknessMin
+			att.setThickness(t/2.0, t/2.0)
+			if(i == n-1):
+				att.setThickness(self._thicknessMin/2.0, self._thicknessMin/2.0)
+			i = i+1
+			it.increment()
+
+class pyDecreasingThicknessShader(StrokeShader):
+	def __init__(self, thicknessMax, thicknessMin):
+		StrokeShader.__init__(self)
+		self._thicknessMin = thicknessMin
+		self._thicknessMax = thicknessMax
+
+	def getName(self):
+		return "pyDecreasingThicknessShader"
+	def shade(self, stroke):
+		l = stroke.getLength2D()
+		tMax = self._thicknessMax
+		if(self._thicknessMax > 0.33*l):
+			tMax = 0.33*l
+		tMin = self._thicknessMin
+		if(self._thicknessMin > 0.1*l):
+			tMin = 0.1*l
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			c = float(i)/float(n)
+			t = (1.0 - c)*tMax +c*tMin
+			att.setThickness(t/2.0, t/2.0)
+			i = i+1
+			it.increment()
+
+def smoothC( a, exp ):
+	c = pow(float(a),exp)*pow(2.0,exp)
+	return c
+
+class pyNonLinearVaryingThicknessShader(StrokeShader):
+	def __init__(self, thicknessExtremity, thicknessMiddle, exponent):
+		StrokeShader.__init__(self)
+		self._thicknessMin = thicknessMiddle
+		self._thicknessMax = thicknessExtremity
+		self._exponent = exponent
+
+	def getName(self):
+		return "pyNonLinearVaryingThicknessShader"
+	def shade(self, stroke):
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			if(i < float(n)/2.0):
+				c = float(i)/float(n)
+			else:
+				c = float(n-i)/float(n)
+			c = smoothC(c, self._exponent)
+			t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
+			att.setThickness(t/2.0, t/2.0)
+			i = i+1
+			it.increment()
+
+## Spherical linear interpolation (cos)
+class pySLERPThicknessShader(StrokeShader):
+	def __init__(self, thicknessMin, thicknessMax, omega=1.2):
+		StrokeShader.__init__(self)
+		self._thicknessMin = thicknessMin
+		self._thicknessMax = thicknessMax
+		self._omega = omega
+
+	def getName(self):
+		return "pySLERPThicknessShader"
+	def shade(self, stroke):
+		slength = stroke.getLength2D()
+		tmp = 0.33*slength
+		maxT = self._thicknessMax
+		if(tmp < self._thicknessMax):
+			maxT = tmp
+		
+		n = stroke.strokeVerticesSize()
+		i = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			c = float(i)/float(n)
+			if(i < float(n)/2.0):
+				t = sin((1-c)*self._omega)/sinh(self._omega)*self._thicknessMin + sin(c*self._omega)/sinh(self._omega) * maxT
+			else:
+				t = sin((1-c)*self._omega)/sinh(self._omega)*maxT + sin(c*self._omega)/sinh(self._omega) * self._thicknessMin
+			att.setThickness(t/2.0, t/2.0)
+			i = i+1
+			it.increment()
+
+class pyTVertexThickenerShader(StrokeShader): ## FIXME
+	def __init__(self, a=1.5, n=3):
+		StrokeShader.__init__(self)
+		self._a = a
+		self._n = n
+
+	def getName(self):
+		return "pyTVertexThickenerShader"
+
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		predTVertex = pyVertexNatureUP0D(T_VERTEX)
+		while it.isEnd() == 0:
+			if(predTVertex(it) == 1):
+				it2 = StrokeVertexIterator(it)
+				it2.increment()
+				if not(it.isBegin() or it2.isEnd()):
+					it.increment()
+					continue
+				n = self._n
+				a = self._a
+				if(it.isBegin()):
+					it3 = StrokeVertexIterator(it)
+					count = 0
+					while (it3.isEnd() == 0 and count < n):
+						att = it3.getObject().attribute()
+						tr = att.getThicknessR();
+						tl = att.getThicknessL();
+						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
+						#r = (1.0-a)/float(n-1)*count + a
+						att.setThickness(r*tr, r*tl)	
+						it3.increment()
+						count = count + 1
+				if(it2.isEnd()):
+					it4 = StrokeVertexIterator(it)
+					count = 0
+					while (it4.isBegin() == 0 and count < n):
+						att = it4.getObject().attribute()
+						tr = att.getThicknessR();
+						tl = att.getThicknessL();
+						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
+						#r = (1.0-a)/float(n-1)*count + a
+						att.setThickness(r*tr, r*tl)	
+						it4.decrement()
+						count = count + 1
+					if ((it4.isBegin() == 1)):
+						att = it4.getObject().attribute()
+						tr = att.getThicknessR();
+						tl = att.getThicknessL();
+						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
+						#r = (1.0-a)/float(n-1)*count + a
+						att.setThickness(r*tr, r*tl)	
+			it.increment()
+
+class pyImportance2DThicknessShader(StrokeShader):
+	def __init__(self, x, y, w, kmin, kmax):
+		StrokeShader.__init__(self)
+		self._x = x
+		self._y = y
+		self._w = float(w)
+		self._kmin = float(kmin)
+		self._kmax = float(kmax)
+
+	def getName(self):
+		return "pyImportanceThicknessShader"
+	def shade(self, stroke):
+		origin = Vec2(self._x, self._y)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			v = it.getObject()
+			p = Vec2(v.getProjectedX(), v.getProjectedY())
+			d = (p-origin).length()
+			if(d>self._w):
+				k = self._kmin
+			else:
+				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
+			att = v.attribute()
+			tr = att.getThicknessR()
+			tl = att.getThicknessL()
+			att.setThickness(k*tr/2.0, k*tl/2.0)
+			it.increment()
+
+class pyImportance3DThicknessShader(StrokeShader):
+	def __init__(self, x, y, z, w, kmin, kmax):
+		StrokeShader.__init__(self)
+		self._x = x
+		self._y = y
+		self._z = z
+		self._w = float(w)
+		self._kmin = float(kmin)
+		self._kmax = float(kmax)
+
+	def getName(self):
+		return "pyImportance3DThicknessShader"
+	def shade(self, stroke):
+		origin = Vec3(self._x, self._y, self._z)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			v = it.getObject()
+			p = Vec3(v.getX(), v.getY(), v.getZ())
+			d = (p-origin).length()
+			if(d>self._w):
+				k = self._kmin
+			else:
+				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
+			att = v.attribute()
+			tr = att.getThicknessR()
+			tl = att.getThicknessL()
+			att.setThickness(k*tr/2.0, k*tl/2.0)
+			it.increment()
+
+class pyZDependingThicknessShader(StrokeShader):
+	def __init__(self, min, max):
+		StrokeShader.__init__(self)
+		self.__min = min
+		self.__max = max
+		self.__func = GetProjectedZF0D()
+	def getName(self):
+		return "pyZDependingThicknessShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		z_min = 1
+		z_max = 0
+		while it.isEnd() == 0:
+			z = self.__func(it.castToInterface0DIterator())
+			if z < z_min:
+				z_min = z
+			elif z > z_max:
+				z_max = z
+			it.increment()
+		z_diff = 1 / (z_max - z_min)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			z = (self.__func(it.castToInterface0DIterator()) - z_min) * z_diff
+			thickness = (1 - z) * self.__max + z * self.__min
+			it.getObject().attribute().setThickness(thickness, thickness)
+			it.increment()
+
+
+## color modifiers
+##################
+
+class pyConstantColorShader(StrokeShader):
+	def __init__(self,r,g,b, a = 1):
+		StrokeShader.__init__(self)
+		self._r = r
+		self._g = g
+		self._b = b
+		self._a = a
+	def getName(self):
+		return "pyConstantColorShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			att.setColor(self._r, self._g, self._b)
+			att.setAlpha(self._a)
+			it.increment()
+
+#c1->c2
+class pyIncreasingColorShader(StrokeShader):
+	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
+		StrokeShader.__init__(self)
+		self._c1 = [r1,g1,b1,a1]
+		self._c2 = [r2,g2,b2,a2]
+	def getName(self):
+		return "pyIncreasingColorShader"
+	def shade(self, stroke):
+		n = stroke.strokeVerticesSize() - 1
+		inc = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			c = float(inc)/float(n)
+
+			att.setColor(  (1-c)*self._c1[0] + c*self._c2[0], 
+				      (1-c)*self._c1[1] + c*self._c2[1],
+			                    (1-c)*self._c1[2] + c*self._c2[2],)
+			att.setAlpha((1-c)*self._c1[3] + c*self._c2[3],)
+			inc = inc+1
+			it.increment()
+
+# c1->c2->c1
+class pyInterpolateColorShader(StrokeShader):
+	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
+		StrokeShader.__init__(self)
+		self._c1 = [r1,g1,b1,a1]
+		self._c2 = [r2,g2,b2,a2]
+	def getName(self):
+		return "pyInterpolateColorShader"
+	def shade(self, stroke):
+		n = stroke.strokeVerticesSize() - 1
+		inc = 0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			u = float(inc)/float(n)
+			c = 1-2*(fabs(u-0.5))
+			att.setColor(  (1-c)*self._c1[0] + c*self._c2[0], 
+				      (1-c)*self._c1[1] + c*self._c2[1],
+			                    (1-c)*self._c1[2] + c*self._c2[2],)
+			att.setAlpha((1-c)*self._c1[3] + c*self._c2[3],)
+			inc = inc+1
+			it.increment()
+
+class pyMaterialColorShader(StrokeShader):
+	def __init__(self, threshold=50):
+		StrokeShader.__init__(self)
+		self._threshold = threshold
+
+	def getName(self):
+		return "pyMaterialColorShader"
+
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		func = MaterialF0D()
+		xn = 0.312713
+		yn = 0.329016
+		Yn = 1.0
+		un = 4.* xn/ ( -2.*xn + 12.*yn + 3. )
+		vn= 9.* yn/ ( -2.*xn + 12.*yn +3. )	
+		while it.isEnd() == 0:
+			toto = it.castToInterface0DIterator()
+			mat = func(toto)
+			
+			r = mat.diffuseR()
+			g = mat.diffuseG()
+			b = mat.diffuseB()
+
+			X = 0.412453*r + 0.35758 *g + 0.180423*b
+			Y = 0.212671*r + 0.71516 *g + 0.072169*b
+			Z = 0.019334*r + 0.119193*g + 0.950227*b
+
+			if((X == 0) and (Y == 0) and (Z == 0)):
+				X = 0.01
+				Y = 0.01
+				Z = 0.01
+			u = 4.*X / (X + 15.*Y + 3.*Z)
+			v = 9.*Y / (X + 15.*Y + 3.*Z)
+			
+			L= 116. * math.pow((Y/Yn),(1./3.)) -16
+			U = 13. * L * (u - un)
+			V = 13. * L * (v - vn)
+			
+			if (L > self._threshold):
+				L = L/1.3
+				U = U+10
+			else:
+				L = L +2.5*(100-L)/5.
+				U = U/3.0
+				V = V/3.0				
+			u = U / (13. * L) + un
+			v = V / (13. * L) + vn
+			
+			Y = Yn * math.pow( ((L+16.)/116.), 3.)
+			X = -9. * Y * u / ((u - 4.)* v - u * v)
+			Z = (9. * Y - 15*v*Y - v*X) /( 3. * v)
+			
+			r = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
+			g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z
+			b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
+
+			att = it.getObject().attribute()
+			att.setColor(r, g, b)
+			it.increment()
+
+class pyRandomColorShader(StrokeShader):
+	def getName(self):
+		return "pyRandomColorShader"
+	def __init__(self, s=1):
+		StrokeShader.__init__(self)
+		seed(s)
+	def shade(self, stroke):
+		## pick a random color
+		c0 = float(uniform(15,75))/100.0
+		c1 = float(uniform(15,75))/100.0
+		c2 = float(uniform(15,75))/100.0
+		print c0, c1, c2
+		it = stroke.strokeVerticesBegin()
+		while(it.isEnd() == 0):
+			it.getObject().attribute().setColor(c0,c1,c2)
+			it.increment()
+
+class py2DCurvatureColorShader(StrokeShader):
+	def getName(self):
+		return "py2DCurvatureColorShader"
+
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		func = Curvature2DAngleF0D()
+		while it.isEnd() == 0:
+			toto = it.castToInterface0DIterator()
+			sv = it.getObject()
+			att = sv.attribute()
+			c = func(toto)
+			if (c<0):
+ 				print "negative 2D curvature"
+			color = 10.0 * c/3.1415
+			print color
+			att.setColor(color,color,color);
+			it.increment()
+
+class pyTimeColorShader(StrokeShader):
+	def __init__(self, step=0.01):
+		StrokeShader.__init__(self)
+		self._t = 0
+		self._step = step
+	def shade(self, stroke):
+		c = self._t*1.0
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			att = it.getObject().attribute()
+			att.setColor(c,c,c)
+			it.increment()
+		self._t = self._t+self._step
+
+## geometry modifiers
+
+class pySamplingShader(StrokeShader):
+	def __init__(self, sampling):
+		StrokeShader.__init__(self)
+		self._sampling = sampling
+	def getName(self):
+		return "pySamplingShader"
+	def shade(self, stroke):
+		stroke.Resample(float(self._sampling)) 
+
+class pyBackboneStretcherShader(StrokeShader):
+	def __init__(self, l):
+		StrokeShader.__init__(self)
+		self._l = l
+	def getName(self):
+		return "pyBackboneStretcherShader"
+	def shade(self, stroke):
+		it0 = stroke.strokeVerticesBegin()
+		it1 = StrokeVertexIterator(it0)
+		it1.increment()
+		itn = stroke.strokeVerticesEnd()
+		itn.decrement()
+		itn_1 = StrokeVertexIterator(itn)
+		itn_1.decrement()
+		v0 = it0.getObject()
+		v1 = it1.getObject()
+		vn_1 = itn_1.getObject()
+		vn = itn.getObject()
+		p0 = Vec2f(v0.getProjectedX(), v0.getProjectedY())
+		pn = Vec2f(vn.getProjectedX(), vn.getProjectedY())
+		p1 = Vec2f(v1.getProjectedX(), v1.getProjectedY())
+		pn_1 = Vec2f(vn_1.getProjectedX(), vn_1.getProjectedY())
+		d1 = p0-p1
+		d1 = d1/d1.norm()
+		dn = pn-pn_1
+		dn = dn/dn.norm()
+		newFirst = p0+d1*float(self._l)
+		newLast = pn+dn*float(self._l)
+		v0.setPoint(newFirst)
+		vn.setPoint(newLast)
+		
+class pyLengthDependingBackboneStretcherShader(StrokeShader):
+	def __init__(self, l):
+		StrokeShader.__init__(self)
+		self._l = l
+	def getName(self):
+		return "pyBackboneStretcherShader"
+	def shade(self, stroke):
+		l = stroke.getLength2D()
+		stretch = self._l*l 
+		it0 = stroke.strokeVerticesBegin()
+		it1 = StrokeVertexIterator(it0)
+		it1.increment()
+		itn = stroke.strokeVerticesEnd()
+		itn.decrement()
+		itn_1 = StrokeVertexIterator(itn)
+		itn_1.decrement()
+		v0 = it0.getObject()
+		v1 = it1.getObject()
+		vn_1 = itn_1.getObject()
+		vn = itn.getObject()
+		p0 = Vec2f(v0.getProjectedX(), v0.getProjectedY())
+		pn = Vec2f(vn.getProjectedX(), vn.getProjectedY())
+		p1 = Vec2f(v1.getProjectedX(), v1.getProjectedY())
+		pn_1 = Vec2f(vn_1.getProjectedX(), vn_1.getProjectedY())
+		d1 = p0-p1
+		d1 = d1/d1.norm()
+		dn = pn-pn_1
+		dn = dn/dn.norm()
+		newFirst = p0+d1*float(stretch)
+		newLast = pn+dn*float(stretch)
+		v0.setPoint(newFirst)
+		vn.setPoint(newLast)
+
+
+## Shader to replace a stroke by its corresponding tangent
+class pyGuidingLineShader(StrokeShader):
+	def getName(self):
+		return "pyGuidingLineShader"
+	## shading method
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin() 	## get the first vertex
+		itlast = stroke.strokeVerticesEnd() 	## 
+		itlast.decrement()			## get the last one
+		t = itlast.getObject().getPoint() - it.getObject().getPoint()	## tangent direction
+		itmiddle = StrokeVertexIterator(it)	## 
+		while(itmiddle.getObject().u()<0.5):	## look for the stroke middle vertex
+			itmiddle.increment()		##
+		it = StrokeVertexIterator(itmiddle)	
+		it.increment()
+		while(it.isEnd() == 0):			## position all the vertices along the tangent for the right part
+			it.getObject().setPoint(itmiddle.getObject().getPoint() \
+			+t*(it.getObject().u()-itmiddle.getObject().u()))
+			it.increment()
+		it = StrokeVertexIterator(itmiddle)
+		it.decrement()
+		while(it.isBegin() == 0):		## position all the vertices along the tangent for the left part
+			it.getObject().setPoint(itmiddle.getObject().getPoint() \
+			-t*(itmiddle.getObject().u()-it.getObject().u()))
+			it.decrement()
+		it.getObject().setPoint(itmiddle.getObject().getPoint()-t*(itmiddle.getObject().u())) ## first vertex
+
+
+class pyBackboneStretcherNoCuspShader(StrokeShader):
+	def __init__(self, l):
+		StrokeShader.__init__(self)
+		self._l = l
+	def getName(self):
+		return "pyBackboneStretcherNoCuspShader"
+	def shade(self, stroke):
+		it0 = stroke.strokeVerticesBegin()
+		it1 = StrokeVertexIterator(it0)
+		it1.increment()
+		itn = stroke.strokeVerticesEnd()
+		itn.decrement()
+		itn_1 = StrokeVertexIterator(itn)
+		itn_1.decrement()
+		v0 = it0.getObject()
+		v1 = it1.getObject()
+		if((v0.getNature() & CUSP == 0) and (v1.getNature() & CUSP == 0)):
+			p0 = v0.getPoint()
+			p1 = v1.getPoint()
+			d1 = p0-p1
+			d1 = d1/d1.norm()
+			newFirst = p0+d1*float(self._l)
+			v0.setPoint(newFirst)
+		vn_1 = itn_1.getObject()
+		vn = itn.getObject()
+		if((vn.getNature() & CUSP == 0) and (vn_1.getNature() & CUSP == 0)):
+			pn = vn.getPoint()
+			pn_1 = vn_1.getPoint()
+			dn = pn-pn_1
+			dn = dn/dn.norm()
+			newLast = pn+dn*float(self._l)	
+			vn.setPoint(newLast)
+
+normalInfo=Normal2DF0D()
+curvatureInfo=Curvature2DAngleF0D()
+
+def edgestopping(x, sigma): 
+	return exp(- x*x/(2*sigma*sigma))
+
+class pyDiffusion2Shader(StrokeShader):
+	def __init__(self, lambda1, nbIter):
+		StrokeShader.__init__(self)
+		self._lambda = lambda1
+		self._nbIter = nbIter
+		self._normalInfo = Normal2DF0D()
+		self._curvatureInfo = Curvature2DAngleF0D()
+	def getName(self):
+		return "pyDiffusionShader"
+	def shade(self, stroke):
+		for i in range (1, self._nbIter):
+			it = stroke.strokeVerticesBegin()
+			while it.isEnd() == 0:
+				v=it.getObject()
+				p1 = v.getPoint()
+				p2 = self._normalInfo(it.castToInterface0DIterator())*self._lambda*self._curvatureInfo(it.castToInterface0DIterator())
+				v.setPoint(p1+p2)
+				it.increment()
+
+class pyTipRemoverShader(StrokeShader):
+	def __init__(self, l):
+		StrokeShader.__init__(self)
+		self._l = l
+	def getName(self):
+		return "pyTipRemoverShader"
+	def shade(self, stroke):
+		originalSize = stroke.strokeVerticesSize()
+		if(originalSize<4):
+			return
+		verticesToRemove = []
+		oldAttributes = []
+		it = stroke.strokeVerticesBegin()
+		while(it.isEnd() == 0):
+			v = it.getObject()
+			if((v.curvilinearAbscissa() < self._l) or (v.strokeLength()-v.curvilinearAbscissa() < self._l)):
+				verticesToRemove.append(v)
+			oldAttributes.append(StrokeAttribute(v.attribute()))
+			it.increment()
+		if(originalSize-len(verticesToRemove) < 2):
+			return
+		for sv in verticesToRemove:
+			stroke.RemoveVertex(sv)
+		stroke.Resample(originalSize)
+		if(stroke.strokeVerticesSize() != originalSize):
+			print "pyTipRemover: Warning: resampling problem"
+		it = stroke.strokeVerticesBegin()
+		for a in oldAttributes:
+			if(it.isEnd() == 1):
+				break
+			v = it.getObject()
+			v.setAttribute(a)
+			it.increment()
+
+class pyTVertexRemoverShader(StrokeShader):
+	def getName(self):
+		return "pyTVertexRemoverShader"
+	def shade(self, stroke):
+		if(stroke.strokeVerticesSize() <= 3 ):
+			return
+ 		predTVertex = pyVertexNatureUP0D(T_VERTEX)
+		it = stroke.strokeVerticesBegin()
+		itlast = stroke.strokeVerticesEnd()
+		itlast.decrement()
+		if(predTVertex(it) == 1):
+ 			stroke.RemoveVertex(it.getObject())
+		if(predTVertex(itlast) == 1):
+ 			stroke.RemoveVertex(itlast.getObject())
+
+class pyExtremitiesOrientationShader(StrokeShader):
+	def __init__(self, x1,y1,x2=0,y2=0):
+		StrokeShader.__init__(self)
+		self._v1 = Vec2(x1,y1)
+		self._v2 = Vec2(x2,y2)
+	def getName(self):
+		return "pyExtremitiesOrientationShader"
+	def shade(self, stroke):
+		print self._v1.x(),self._v1.y()
+		stroke.setBeginningOrientation(self._v1.x(),self._v1.y())
+		stroke.setEndingOrientation(self._v2.x(),self._v2.y())
+
+class pyHLRShader(StrokeShader):
+	def getName(self):
+		return "pyHLRShader"
+	def shade(self, stroke):
+		originalSize = stroke.strokeVerticesSize()
+		if(originalSize<4):
+			return
+		it = stroke.strokeVerticesBegin()
+		invisible = 0
+		it2 = StrokeVertexIterator(it)
+		it2.increment()
+		fe = getFEdge(it.getObject(), it2.getObject())
+		if(fe.qi() != 0):
+			invisible = 1
+		while(it2.isEnd() == 0):
+			v = it.getObject()
+			vnext = it2.getObject()
+			if(v.getNature() & VIEW_VERTEX):
+				#if(v.getNature() & T_VERTEX):
+				fe = getFEdge(v,vnext)
+				qi = fe.qi()
+				if(qi != 0):
+					invisible = 1
+				else:
+					invisible = 0
+			if(invisible == 1):		
+				v.attribute().setVisible(0)
+			it.increment()
+			it2.increment()
+
+class pyTVertexOrientationShader(StrokeShader):
+	def __init__(self):
+		StrokeShader.__init__(self)
+		self._Get2dDirection = Orientation2DF1D()
+	def getName(self):
+		return "pyTVertexOrientationShader"
+	## finds the TVertex orientation from the TVertex and 
+	## the previous or next edge
+	def findOrientation(self, tv, ve):
+		mateVE = tv.mate(ve)
+		if((ve.qi() != 0) or (mateVE.qi() != 0)):
+			ait = AdjacencyIterator(tv,1,0)
+			winner = None
+			incoming = 1
+			while(ait.isEnd() == 0):
+				ave = ait.getObject()
+				if((ave.getId() != ve.getId()) and (ave.getId() != mateVE.getId())):
+					winner = ait.getObject()
+					if(ait.isIncoming() == 0):
+						incoming = 0
+						break
+				ait.increment()
+			if(winner != None):
+				if(incoming != 0):
+					direction = self._Get2dDirection(winner.fedgeB())
+				else:
+					direction = self._Get2dDirection(winner.fedgeA())
+				return direction
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it2 = StrokeVertexIterator(it)
+		it2.increment()
+		## case where the first vertex is a TVertex
+		v = it.getObject() 
+		if(v.getNature() & T_VERTEX):
+			tv = v.castToTVertex()
+			ve = getFEdge(v, it2.getObject()).viewedge()
+			if(tv != None):			
+				dir = self.findOrientation(tv, ve)
+				#print dir.x(), dir.y()
+				v.attribute().setAttributeVec2f("orientation", dir)
+		while(it2.isEnd() == 0):
+			vprevious = it.getObject()
+			v = it2.getObject()
+			if(v.getNature() & T_VERTEX):
+				tv = v.castToTVertex()
+				ve = getFEdge(vprevious, v).viewedge()
+				if(tv != None):	
+					dir = self.findOrientation(tv, ve)
+					#print dir.x(), dir.y()
+					v.attribute().setAttributeVec2f("orientation", dir)			
+			it.increment()
+			it2.increment()
+		## case where the last vertex is a TVertex
+		v = it.getObject() 
+		if(v.getNature() & T_VERTEX):
+			itPrevious = StrokeVertexIterator(it)
+			itPrevious.decrement()
+			tv = v.castToTVertex()
+			ve = getFEdge(itPrevious.getObject(), v).viewedge()
+			if(tv != None):			
+				dir = self.findOrientation(tv, ve)
+				#print dir.x(), dir.y()
+				v.attribute().setAttributeVec2f("orientation", dir)
+
+class pySinusDisplacementShader(StrokeShader):
+	def __init__(self, f, a):
+		StrokeShader.__init__(self)
+		self._f = f
+		self._a = a
+		self._getNormal = Normal2DF0D()
+
+	def getName(self):
+		return "pySinusDisplacementShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			v = it.getObject()
+			#print self._getNormal.getName()
+			n = self._getNormal(it.castToInterface0DIterator())
+			p = v.getPoint()
+			u = v.u()
+			a = self._a*(1-2*(fabs(u-0.5)))
+			n = n*a*cos(self._f*u*6.28)
+			#print n.x(), n.y()
+			v.setPoint(p+n)
+			#v.setPoint(v.getPoint()+n*a*cos(f*v.u()))
+			it.increment()
+
+class pyPerlinNoise1DShader(StrokeShader):
+	def __init__(self, freq = 10, amp = 10, oct = 4):
+		StrokeShader.__init__(self)
+		self.__noise = Noise()
+		self.__freq = freq
+		self.__amp = amp
+		self.__oct = oct
+	def getName(self):
+		return "pyPerlinNoise1DShader"
+	def shade(self, stroke):
+		i = randint(0, 50)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			v = it.getObject()
+			nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)
+			v.setPoint(v.getProjectedX() + nres, v.getProjectedY() + nres)
+			i = i+1
+			it.increment()
+
+class pyPerlinNoise2DShader(StrokeShader):
+	def __init__(self, freq = 10, amp = 10, oct = 4):
+		StrokeShader.__init__(self)
+		self.__noise = Noise()
+		self.__freq = freq
+		self.__amp = amp
+		self.__oct = oct
+	def getName(self):
+		return "pyPerlinNoise2DShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			v = it.getObject()
+			vec = Vec2f(v.getProjectedX(), v.getProjectedY())
+			nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
+			v.setPoint(v.getProjectedX() + nres, v.getProjectedY() + nres)
+			it.increment()
+
+class pyBluePrintCirclesShader(StrokeShader):
+	def __init__(self, turns = 1):
+		StrokeShader.__init__(self)
+		self.__turns = turns
+	def getName(self):
+		return "pyBluePrintCirclesShader"
+	def shade(self, stroke):
+		p_min = Vec2f(10000, 10000)
+		p_max = Vec2f(0, 0)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			p = it.getObject().getPoint()
+			if (p.x() < p_min.x()):
+				p_min.setX(p.x())
+			if (p.x() > p_max.x()):
+				p_max.setX(p.x())
+			if (p.y() < p_min.y()):
+				p_min.setY(p.y())
+			if (p.y() > p_max.y()):
+				p_max.setY(p.y())
+			it.increment()
+		stroke.Resample(32 * self.__turns)
+		sv_nb = stroke.strokeVerticesSize()
+#		print "min  :", p_min.x(), p_min.y() # DEBUG
+#		print "mean :", p_sum.x(), p_sum.y() # DEBUG
+#		print "max  :", p_max.x(), p_max.y() # DEBUG
+#		print "----------------------" # DEBUG
+#######################################################	
+		sv_nb = sv_nb / self.__turns
+		center = (p_min + p_max) / 2
+		radius = (center.x() - p_min.x() + center.y() - p_min.y()) / 2
+		p_new = Vec2f()
+#######################################################
+		it = stroke.strokeVerticesBegin()
+		for j in range(self.__turns):
+			radius = radius + randint(-3, 3)
+			center_x = center.x() + randint(-5, 5)
+			center_y = center.y() + randint(-5, 5)
+			center.setX(center_x)
+			center.setY(center_y)
+			i = 0
+			while i < sv_nb:
+				p_new.setX(center.x() + radius * cos(2 * pi * float(i) / float(sv_nb - 1)))
+   				p_new.setY(center.y() + radius * sin(2 * pi * float(i) / float(sv_nb - 1)))
+				it.getObject().setPoint(p_new.x(), p_new.y())
+				i = i + 1
+				it.increment()
+		while it.isEnd() == 0:
+			stroke.RemoveVertex(it.getObject())
+			it.increment()
+
+
+class pyBluePrintEllipsesShader(StrokeShader):
+	def __init__(self, turns = 1):
+		StrokeShader.__init__(self)
+		self.__turns = turns
+	def getName(self):
+		return "pyBluePrintEllipsesShader"
+	def shade(self, stroke):
+		p_min = Vec2f(10000, 10000)
+		p_max = Vec2f(0, 0)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			p = it.getObject().getPoint()
+			if (p.x() < p_min.x()):
+				p_min.setX(p.x())
+			if (p.x() > p_max.x()):
+				p_max.setX(p.x())
+			if (p.y() < p_min.y()):
+				p_min.setY(p.y())
+			if (p.y() > p_max.y()):
+				p_max.setY(p.y())
+			it.increment()
+		stroke.Resample(32 * self.__turns)
+		sv_nb = stroke.strokeVerticesSize()
+#		print "min  :", p_min.x(), p_min.y() # DEBUG
+#		print "mean :", p_sum.x(), p_sum.y() # DEBUG
+#		print "max  :", p_max.x(), p_max.y() # DEBUG
+#		print "----------------------" # DEBUG
+#######################################################	
+		sv_nb = sv_nb / self.__turns
+		center = (p_min + p_max) / 2
+		radius_x = center.x() - p_min.x()
+		radius_y = center.y() - p_min.y()
+		p_new = Vec2f()
+#######################################################
+		it = stroke.strokeVerticesBegin()
+		for j in range(self.__turns):
+			radius_x = radius_x + randint(-3, 3)
+			radius_y = radius_y + randint(-3, 3)
+			center_x = center.x() + randint(-5, 5)
+			center_y = center.y() + randint(-5, 5)
+			center.setX(center_x)
+			center.setY(center_y)
+			i = 0
+			while i < sv_nb:
+				p_new.setX(center.x() + radius_x * cos(2 * pi * float(i) / float(sv_nb - 1)))
+   				p_new.setY(center.y() + radius_y * sin(2 * pi * float(i) / float(sv_nb - 1)))
+				it.getObject().setPoint(p_new.x(), p_new.y())
+				i = i + 1
+				it.increment()
+		while it.isEnd() == 0:
+			stroke.RemoveVertex(it.getObject())
+			it.increment()
+
+
+class pyBluePrintSquaresShader(StrokeShader):
+	def __init__(self, turns = 1, bb_len = 10):
+		StrokeShader.__init__(self)
+		self.__turns = turns
+		self.__bb_len = bb_len
+	def getName(self):
+		return "pyBluePrintSquaresShader"
+	def shade(self, stroke):
+		p_min = Vec2f(10000, 10000)
+		p_max = Vec2f(0, 0)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			p = it.getObject().getPoint()
+			if (p.x() < p_min.x()):
+				p_min.setX(p.x())
+			if (p.x() > p_max.x()):
+				p_max.setX(p.x())
+			if (p.y() < p_min.y()):
+				p_min.setY(p.y())
+			if (p.y() > p_max.y()):
+				p_max.setY(p.y())
+			it.increment()
+		stroke.Resample(32 * self.__turns)
+		sv_nb = stroke.strokeVerticesSize()
+#######################################################	
+		sv_nb = sv_nb / self.__turns
+		first = sv_nb / 4
+		second = 2 * first
+		third = 3 * first
+		fourth = sv_nb
+		vec_first = Vec2f(p_max.x() - p_min.x() + 2 * self.__bb_len, 0)
+		vec_second = Vec2f(0, p_max.y() - p_min.y() + 2 * self.__bb_len)
+		vec_third = vec_first * -1
+		vec_fourth = vec_second * -1
+		p_first = Vec2f(p_min.x() - self.__bb_len, p_min.y())
+		p_second = Vec2f(p_max.x(), p_min.y() - self.__bb_len)
+		p_third = Vec2f(p_max.x() + self.__bb_len, p_max.y())
+		p_fourth = Vec2f(p_min.x(), p_max.y() + self.__bb_len)
+#######################################################
+		it = stroke.strokeVerticesBegin()
+		visible = 1
+		for j in range(self.__turns):
+			i = 0
+			while i < sv_nb:
+				if i < first:
+					p_new = p_first + vec_first * float(i)/float(first - 1)
+					if i == first - 1:
+						visible = 0
+				elif i < second:
+					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
+					if i == second - 1:
+						visible = 0
+				elif i < third:
+					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
+					if i == third - 1:
+						visible = 0
+				else:
+					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
+					if i == fourth - 1:
+						visible = 0
+				it.getObject().setPoint(p_new.x(), p_new.y())
+				it.getObject().attribute().setVisible(visible)
+				if visible == 0:
+					visible = 1
+				i = i + 1
+				it.increment()
+		while it.isEnd() == 0:
+			stroke.RemoveVertex(it.getObject())
+			it.increment()
+
+
+class pyBluePrintDirectedSquaresShader(StrokeShader):
+	def __init__(self, turns = 1, bb_len = 10, mult = 1):
+		StrokeShader.__init__(self)
+		self.__mult = mult
+		self.__turns = turns
+		self.__bb_len = 1 + float(bb_len) / 100
+	def getName(self):
+		return "pyBluePrintDirectedSquaresShader"
+	def shade(self, stroke):
+		stroke.Resample(32 * self.__turns)
+		p_mean = Vec2f(0, 0)
+		p_min = Vec2f(10000, 10000)
+		p_max = Vec2f(0, 0)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			p = it.getObject().getPoint()
+			p_mean = p_mean + p
+## 			if (p.x() < p_min.x()):
+## 				p_min.setX(p.x())
+## 			if (p.x() > p_max.x()):
+## 				p_max.setX(p.x())
+## 			if (p.y() < p_min.y()):
+## 				p_min.setY(p.y())
+## 			if (p.y() > p_max.y()):
+## 				p_max.setY(p.y())
+			it.increment()
+		sv_nb = stroke.strokeVerticesSize()
+		p_mean = p_mean / sv_nb
+		p_var_xx = 0
+		p_var_yy = 0
+		p_var_xy = 0
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			p = it.getObject().getPoint()
+			p_var_xx = p_var_xx + pow(p.x() - p_mean.x(), 2)
+			p_var_yy = p_var_yy + pow(p.y() - p_mean.y(), 2)
+			p_var_xy = p_var_xy + (p.x() - p_mean.x()) * (p.y() - p_mean.y())
+			it.increment()
+		p_var_xx = p_var_xx / sv_nb
+		p_var_yy = p_var_yy / sv_nb
+		p_var_xy = p_var_xy / sv_nb
+##		print p_var_xx, p_var_yy, p_var_xy
+		trace = p_var_xx + p_var_yy
+		det = p_var_xx * p_var_yy - p_var_xy * p_var_xy
+		sqrt_coeff = sqrt(trace * trace - 4 * det)
+		lambda1 = (trace + sqrt_coeff) / 2
+		lambda2 = (trace - sqrt_coeff) / 2
+##		print lambda1, lambda2
+		theta = atan(2 * p_var_xy / (p_var_xx - p_var_yy)) / 2
+##		print theta
+		if p_var_yy > p_var_xx:
+			e1 = Vec2f(cos(theta + pi / 2), sin(theta + pi / 2)) * sqrt(lambda1) * self.__mult
+			e2 = Vec2f(cos(theta + pi), sin(theta + pi)) *  sqrt(lambda2) * self.__mult
+		else:
+			e1 = Vec2f(cos(theta), sin(theta)) * sqrt(lambda1) * self.__mult
+			e2 = Vec2f(cos(theta + pi / 2), sin(theta + pi / 2)) * sqrt(lambda2) * self.__mult
+#######################################################	
+		sv_nb = sv_nb / self.__turns
+		first = sv_nb / 4
+		second = 2 * first
+		third = 3 * first
+		fourth = sv_nb
+		bb_len1 = self.__bb_len
+		bb_len2 = 1 + (bb_len1 - 1) * sqrt(lambda1 / lambda2)
+		p_first = p_mean - e1 - e2 * bb_len2
+		p_second = p_mean - e1 * bb_len1 + e2
+		p_third = p_mean + e1 + e2 * bb_len2
+		p_fourth = p_mean + e1 * bb_len1 - e2
+		vec_first = e2 * bb_len2 * 2
+		vec_second = e1 * bb_len1 * 2
+		vec_third = vec_first * -1
+		vec_fourth = vec_second * -1
+#######################################################
+		it = stroke.strokeVerticesBegin()
+		visible = 1
+		for j in range(self.__turns):
+			i = 0
+			while i < sv_nb:
+				if i < first:
+					p_new = p_first + vec_first * float(i)/float(first - 1)
+					if i == first - 1:
+						visible = 0
+				elif i < second:
+					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
+					if i == second - 1:
+						visible = 0
+				elif i < third:
+					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
+					if i == third - 1:
+						visible = 0
+				else:
+					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
+					if i == fourth - 1:
+						visible = 0
+				it.getObject().setPoint(p_new.x(), p_new.y())
+				it.getObject().attribute().setVisible(visible)
+				if visible == 0:
+					visible = 1
+				i = i + 1
+				it.increment()
+		while it.isEnd() == 0:
+			stroke.RemoveVertex(it.getObject())
+			it.increment()
+
+class pyModulateAlphaShader(StrokeShader):
+	def __init__(self, min = 0, max = 1):
+		StrokeShader.__init__(self)
+		self.__min = min
+		self.__max = max
+	def getName(self):
+		return "pyModulateAlphaShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			alpha = it.getObject().attribute().getAlpha()
+			p = it.getObject().getPoint()
+			alpha = alpha * p.y() / 400
+			if alpha < self.__min:
+				alpha = self.__min
+			elif alpha > self.__max:
+				alpha = self.__max
+			it.getObject().attribute().setAlpha(alpha)
+			it.increment()
+
+
+## various
+class pyDummyShader(StrokeShader):
+	def getName(self):
+		return "pyDummyShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		it_end = stroke.strokeVerticesEnd()
+		while it.isEnd() == 0:
+			toto = it.castToInterface0DIterator()
+			att = it.getObject().attribute()
+			att.setColor(0.3, 0.4, 0.4)
+			att.setThickness(0, 5)
+			it.increment()
+
+class pyDebugShader(StrokeShader):
+	def getName(self):
+		return "pyDebugShader"
+
+ 	def shade(self, stroke):
+		fe = GetSelectedFEdgeCF()
+		id1=fe.vertexA().getId()
+		id2=fe.vertexB().getId()
+		#print id1.getFirst(), id1.getSecond()
+		#print id2.getFirst(), id2.getSecond()
+		it = stroke.strokeVerticesBegin()
+		found = 0
+		foundfirst = 0
+		foundsecond = 0
+		while it.isEnd() == 0:
+			cp = it.getObject()
+			if((cp.A().getId() == id1) or (cp.B().getId() == id1)):
+				foundfirst = 1
+			if((cp.A().getId() == id2) or (cp.B().getId() == id2)):
+				foundsecond = 1
+			if((foundfirst != 0) and (foundsecond != 0)):
+				found = 1
+				break
+			it.increment()
+		if(found != 0):
+			print "The selected Stroke id is: ", stroke.getId().getFirst(), stroke.getId().getSecond()
+
diff --git a/source/blender/freestyle/style_modules/sketchy_multiple_parameterization.py b/source/blender/freestyle/style_modules/sketchy_multiple_parameterization.py
new file mode 100755
index 00000000000..69e6f11751d
--- /dev/null
+++ b/source/blender/freestyle/style_modules/sketchy_multiple_parameterization.py
@@ -0,0 +1,48 @@
+#
+#  Filename : sketchy_multiple_parameterization.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Builds sketchy strokes whose topology relies on a 
+#             parameterization that covers the complete lines (visible+invisible)
+#             whereas only the visible portions are actually drawn
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+## 0: don't restrict to selection
+Operators.bidirectionalChain(pySketchyChainSilhouetteIterator(3,0))
+shaders_list = 	[
+		SamplingShader(2),
+		SpatialNoiseShader(15, 120, 2, 1, 1), 
+		IncreasingThicknessShader(5, 30), 
+		SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
+		IncreasingColorShader(0,0.2,0,1,0.2,0.7,0.2,1),
+		TextureAssignerShader(6),
+		pyHLRShader()
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/sketchy_topology_broken.py b/source/blender/freestyle/style_modules/sketchy_topology_broken.py
new file mode 100755
index 00000000000..7383347a0fb
--- /dev/null
+++ b/source/blender/freestyle/style_modules/sketchy_topology_broken.py
@@ -0,0 +1,89 @@
+#
+#  Filename : sketchy_topology_broken.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The topology of the strokes is, first, built
+#             independantly from the 3D topology of objects, 
+#             and, second, so as to chain several times the same ViewEdge.
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+## Backbone stretcher that leaves cusps intact to avoid cracks
+class pyBackboneStretcherNoCuspShader(StrokeShader):
+	def __init__(self, l):
+		StrokeShader.__init__(self)
+		self._l = l
+	def getName(self):
+		return "pyBackboneStretcherNoCuspShader"
+	def shade(self, stroke):
+		it0 = stroke.strokeVerticesBegin()
+		it1 = StrokeVertexIterator(it0)
+		it1.increment()
+		itn = stroke.strokeVerticesEnd()
+		itn.decrement()
+		itn_1 = StrokeVertexIterator(itn)
+		itn_1.decrement()
+		v0 = it0.getObject()
+		v1 = it1.getObject()
+		if((v0.getNature() & CUSP == 0) and (v1.getNature() & CUSP == 0)):
+			p0 = v0.getPoint()
+			p1 = v1.getPoint()
+			d1 = p0-p1
+			d1 = d1/d1.norm()
+			newFirst = p0+d1*float(self._l)
+			v0.setPoint(newFirst)
+		else:
+			print "got a v0 cusp"
+		vn_1 = itn_1.getObject()
+		vn = itn.getObject()
+		if((vn.getNature() & CUSP == 0) and (vn_1.getNature() & CUSP == 0)):
+			pn = vn.getPoint()
+			pn_1 = vn_1.getPoint()
+			dn = pn-pn_1
+			dn = dn/dn.norm()
+			newLast = pn+dn*float(self._l)	
+			vn.setPoint(newLast)
+		else:
+			print "got a vn cusp"
+
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+## Chain 3 times each ViewEdge indpendantly from the 
+## initial objects topology
+Operators.bidirectionalChain(pySketchyChainingIterator(3))
+shaders_list = 	[
+		SamplingShader(4),
+		SpatialNoiseShader(6, 120, 2, 1, 1), 
+		IncreasingThicknessShader(4, 10), 
+		SmoothingShader(100, 0.1, 0, 0.2, 0, 0, 0, 1),
+		pyBackboneStretcherNoCuspShader(20),
+		#ConstantColorShader(0.0,0.0,0.0)
+		IncreasingColorShader(0.2,0.2,0.2,1,0.5,0.5,0.5,1),
+		#IncreasingColorShader(1,0,0,1,0,1,0,1),
+		TextureAssignerShader(4)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/sketchy_topology_preserved.py b/source/blender/freestyle/style_modules/sketchy_topology_preserved.py
new file mode 100755
index 00000000000..bc56a272bd5
--- /dev/null
+++ b/source/blender/freestyle/style_modules/sketchy_topology_preserved.py
@@ -0,0 +1,49 @@
+#
+#  Filename : sketchy_topology_preserved.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The topology of the strokes is built
+#             so as to chain several times the same ViewEdge.
+#             The topology of the objects is preserved
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = QuantitativeInvisibilityUP1D(0)
+Operators.select(upred)
+Operators.bidirectionalChain(pySketchyChainSilhouetteIterator(3,1))
+shaders_list = 	[
+		SamplingShader(4),
+		SpatialNoiseShader(20, 220, 2, 1, 1), 
+		IncreasingThicknessShader(4, 8), 
+		SmoothingShader(300, 0.05, 0, 0.2, 0, 0, 0, 0.5),
+		ConstantColorShader(0.6,0.2,0.0),
+		TextureAssignerShader(4),
+		]
+
+Operators.create(TrueUP1D(), shaders_list)
+
diff --git a/source/blender/freestyle/style_modules/split_at_highest_2d_curvatures.py b/source/blender/freestyle/style_modules/split_at_highest_2d_curvatures.py
new file mode 100755
index 00000000000..0f42080292b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/split_at_highest_2d_curvatures.py
@@ -0,0 +1,40 @@
+#
+#  Filename : split_at_highest_2d_curvature.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the visible lines (chaining follows same nature lines)
+#             (most basic style module)
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from Functions0D import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursiveSplit(func,  pyParameterUP0D(0.4,0.6), NotUP1D(pyHigherLengthUP1D(100)), 2)
+shaders_list = [ConstantThicknessShader(10), IncreasingColorShader(1,0,0,1,0,1,0,1), TextureAssignerShader(3)]
+Operators.create(TrueUP1D(), shaders_list)
+
diff --git a/source/blender/freestyle/style_modules/split_at_tvertices.py b/source/blender/freestyle/style_modules/split_at_tvertices.py
new file mode 100755
index 00000000000..dde586fd1f0
--- /dev/null
+++ b/source/blender/freestyle/style_modules/split_at_tvertices.py
@@ -0,0 +1,42 @@
+#
+#  Filename : split_at_tvertices.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws strokes that starts and stops at Tvertices (visible or not)
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesU0D import *
+from Functions0D import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+start = pyVertexNatureUP0D(T_VERTEX)
+## use the same predicate to decide where to start and where to stop 
+## the strokes:
+Operators.sequentialSplit(start, start, 10)
+shaders_list = [ConstantThicknessShader(5), IncreasingColorShader(1,0,0,1,0,1,0,1), TextureAssignerShader(3)]
+Operators.create(TrueUP1D(), shaders_list)
+
diff --git a/source/blender/freestyle/style_modules/stroke_texture.py b/source/blender/freestyle/style_modules/stroke_texture.py
new file mode 100755
index 00000000000..d6c753bf9e6
--- /dev/null
+++ b/source/blender/freestyle/style_modules/stroke_texture.py
@@ -0,0 +1,43 @@
+#
+#  Filename : stroke_texture.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws textured strokes (illustrate the StrokeTextureShader shader)
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+from ChainingIterators import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		SamplingShader(3),
+		BezierCurveShader(4),
+		StrokeTextureShader("washbrushAlpha.bmp", Stroke.DRY_MEDIUM, 1),
+		ConstantThicknessShader(40),
+		ConstantColorShader(0,0,0,1),
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/suggestive.py b/source/blender/freestyle/style_modules/suggestive.py
new file mode 100755
index 00000000000..99a419ca23f
--- /dev/null
+++ b/source/blender/freestyle/style_modules/suggestive.py
@@ -0,0 +1,43 @@
+#
+#  Filename : suggestive.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the suggestive contours.
+#             ***** The suggestive contours must be enabled
+#             in the options dialog *****
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(pyNatureUP1D(SUGGESTIVE_CONTOUR), QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = 	[
+		IncreasingThicknessShader(1, 3), 
+		ConstantColorShader(0.2,0.2,0.2, 1)
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/thickness_fof_depth_discontinuity.py b/source/blender/freestyle/style_modules/thickness_fof_depth_discontinuity.py
new file mode 100755
index 00000000000..06687fd9a00
--- /dev/null
+++ b/source/blender/freestyle/style_modules/thickness_fof_depth_discontinuity.py
@@ -0,0 +1,62 @@
+#
+#  Filename : thickness_fof_depth_discontinuity.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Assigns to strokes a thickness that depends on the depth discontinuity
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+class pyDepthDiscontinuityThicknessShader(StrokeShader):
+	def __init__(self, min, max):
+		StrokeShader.__init__(self)
+		self.__min = float(min)
+		self.__max = float(max)
+		self.__func = ZDiscontinuityF0D()
+	def getName(self):
+		return "pyDepthDiscontinuityThicknessShader"
+	def shade(self, stroke):
+		it = stroke.strokeVerticesBegin()
+		z_min=0.0
+		z_max=1.0
+		a = (self.__max - self.__min)/(z_max-z_min)
+		b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min)
+		it = stroke.strokeVerticesBegin()
+		while it.isEnd() == 0:
+			z = self.__func(it.castToInterface0DIterator())
+			thickness = a*z+b
+			it.getObject().attribute().setThickness(thickness, thickness)
+			it.increment()
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		SamplingShader(1),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0.0,0.0,0.0),
+		pyDepthDiscontinuityThicknessShader(0.8, 6)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/tipremover.py b/source/blender/freestyle/style_modules/tipremover.py
new file mode 100755
index 00000000000..b87eb7a573a
--- /dev/null
+++ b/source/blender/freestyle/style_modules/tipremover.py
@@ -0,0 +1,42 @@
+#
+#  Filename : tipremover.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Removes strokes extremities
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		SamplingShader(5),
+		ConstantThicknessShader(3), 
+		ConstantColorShader(0,0,0),
+		TipRemoverShader(20)
+		]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
diff --git a/source/blender/freestyle/style_modules/tvertex_remover.py b/source/blender/freestyle/style_modules/tvertex_remover.py
new file mode 100755
index 00000000000..b55754381f7
--- /dev/null
+++ b/source/blender/freestyle/style_modules/tvertex_remover.py
@@ -0,0 +1,42 @@
+#
+#  Filename : tvertex_remover.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Removes TVertices
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from Freestyle import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = 	[
+		IncreasingThicknessShader(3, 5), 
+		ConstantColorShader(0.2,0.2,0.2, 1),
+		SamplingShader(10.0),
+		pyTVertexRemoverShader()
+		]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/source/blender/freestyle/style_modules/uniformpruning_zsort.py b/source/blender/freestyle/style_modules/uniformpruning_zsort.py
new file mode 100755
index 00000000000..7e719417af0
--- /dev/null
+++ b/source/blender/freestyle/style_modules/uniformpruning_zsort.py
@@ -0,0 +1,40 @@
+from Freestyle import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesU0D import *
+from PredicatesB1D import *
+from Functions0D import *
+from Functions1D import *
+from shaders import *
+
+class pyDensityUP1D(UnaryPredicate1D):
+	def __init__(self,wsize,threshold, integration = MEAN, sampling=2.0):
+		UnaryPredicate1D.__init__(self)
+		self._wsize = wsize
+		self._threshold = threshold
+		self._integration = integration
+		self._func = DensityF1D(self._wsize, self._integration, sampling)
+			
+	def getName(self):
+		return "pyDensityUP1D"
+
+	def __call__(self, inter):
+		d = self._func(inter)
+		print "For Chain ", inter.getId().getFirst(), inter.getId().getSecond(), "density is ", d
+		if(d < self._threshold):
+			return 1
+		return 0
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator())
+#Operators.sequentialSplit(pyVertexNatureUP0D(VIEW_VERTEX), 2)
+Operators.sort(pyZBP1D())
+shaders_list = 	[
+		StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, 0),
+		ConstantThicknessShader(3), 
+		SamplingShader(5.0),
+		ConstantColorShader(0,0,0,1)
+		]
+Operators.create(pyDensityUP1D(2,0.05, MEAN,4), shaders_list)
+#Operators.create(pyDensityFunctorUP1D(8,0.03, pyGetInverseProjectedZF1D(), 0,1, MEAN), shaders_list)
+
diff --git a/source/blender/freestyle/style_modules/vector.py b/source/blender/freestyle/style_modules/vector.py
new file mode 100755
index 00000000000..039f262546b
--- /dev/null
+++ b/source/blender/freestyle/style_modules/vector.py
@@ -0,0 +1,241 @@
+# This module defines 3d geometrical vectors with the standard
+# operations on them.
+#
+# Written by: Konrad Hinsen 
+# Last revision: 1996-1-26
+#
+
+"""This module defines three-dimensional geometrical vectors. Vectors support
+the usual mathematical operations (v1, v2: vectors, s: scalar): 
+  v1+v2		  addition
+  v1-v2		  subtraction
+  v1*v2		  scalar product
+  s*v1		  multiplication with a scalar
+  v1/s		  division by a scalar
+  v1.cross(v2)	  cross product
+  v1.length()	  length
+  v1.normal()	  normal vector in direction of v1
+  v1.angle(v2)	  angle between two vectors
+  v1.x(), v1[0]	  first element
+  v1.y(), v1[1]	  second element
+  v1.z(), v1[2]	  third element
+
+The module offers the following items for export:
+  Vec3D(x,y,z)	  the constructor for vectors
+  isVector(x)	  a type check function
+  ex, ey, ez	  unit vectors along the x-, y-, and z-axes (predefined constants)
+
+Note: vector elements can be any kind of numbers on which the operations
+addition, subtraction, multiplication, division, comparison, sqrt, and acos
+are defined. Integer elements are treated as floating point elements.
+"""
+
+import math, types
+
+class Vec3:
+
+    isVec3 = 1
+
+    def __init__(self, x=0., y=0., z=0.):
+	self.data = [x,y,z]
+
+    def __repr__(self):
+	return 'Vec3(%s,%s,%s)' % (`self.data[0]`,\
+				     `self.data[1]`,`self.data[2]`)
+
+    def __str__(self):
+	return `self.data`
+
+    def __add__(self, other):
+	return Vec3(self.data[0]+other.data[0],\
+		      self.data[1]+other.data[1],self.data[2]+other.data[2])
+    __radd__ = __add__
+
+    def __neg__(self):
+	return Vec3(-self.data[0], -self.data[1], -self.data[2])
+
+    def __sub__(self, other):
+	return Vec3(self.data[0]-other.data[0],\
+		      self.data[1]-other.data[1],self.data[2]-other.data[2])
+
+    def __rsub__(self, other):
+	return Vec3(other.data[0]-self.data[0],\
+		      other.data[1]-self.data[1],other.data[2]-self.data[2])
+
+    def __mul__(self, other):
+	if isVec3(other):
+	    return reduce(lambda a,b: a+b,
+			  map(lambda a,b: a*b, self.data, other.data))
+	else:
+	    return Vec3(self.data[0]*other, self.data[1]*other,
+			  self.data[2]*other)
+
+    def __rmul__(self, other):
+	if isVec3(other):
+	    return reduce(lambda a,b: a+b,
+			  map(lambda a,b: a*b, self.data, other.data))
+	else:
+	    return Vec3(other*self.data[0], other*self.data[1],
+			  other*self.data[2])
+
+    def __div__(self, other):
+	if isVec3(other):
+	    raise TypeError, "Can't divide by a vector"
+	else:
+	    return Vec3(_div(self.data[0],other), _div(self.data[1],other),
+			  _div(self.data[2],other))
+	    
+    def __rdiv__(self, other):
+	raise TypeError, "Can't divide by a vector"
+
+    def __cmp__(self, other):
+	return cmp(self.data[0],other.data[0]) \
+	       or cmp(self.data[1],other.data[1]) \
+	       or cmp(self.data[2],other.data[2])
+
+    def __getitem__(self, index):
+	return self.data[index]
+
+    def x(self):
+	return self.data[0]
+    def y(self):
+	return self.data[1]
+    def z(self):
+	return self.data[2]
+
+    def length(self):
+	return math.sqrt(self*self)
+
+    def normal(self):
+	len = self.length()
+	if len == 0:
+	    raise ZeroDivisionError, "Can't normalize a zero-length vector"
+	return self/len
+
+    def cross(self, other):
+	if not isVec3(other):
+	    raise TypeError, "Cross product with non-vector"
+	return Vec3(self.data[1]*other.data[2]-self.data[2]*other.data[1],
+		      self.data[2]*other.data[0]-self.data[0]*other.data[2],
+		      self.data[0]*other.data[1]-self.data[1]*other.data[0])
+
+    def angle(self, other):
+	if not isVec3(other):
+	    raise TypeError, "Angle between vector and non-vector"
+	cosa = (self*other)/(self.length()*other.length())
+	cosa = max(-1.,min(1.,cosa))
+	return math.acos(cosa)
+
+
+class Vec2:
+
+    isVec2 = 1
+
+    def __init__(self, x=0., y=0.):
+	self.data = [x,y]
+
+    def __repr__(self):
+	return 'Vec2(%s,%s,%s)' % (`self.data[0]`,\
+				     `self.data[1]`)
+
+    def __str__(self):
+	return `self.data`
+
+    def __add__(self, other):
+	return Vec2(self.data[0]+other.data[0],\
+		      self.data[1]+other.data[1])
+    __radd__ = __add__
+
+    def __neg__(self):
+	return Vec2(-self.data[0], -self.data[1])
+
+    def __sub__(self, other):
+	return Vec2(self.data[0]-other.data[0],\
+		      self.data[1]-other.data[1])
+
+    def __rsub__(self, other):
+	return Vec2(other.data[0]-self.data[0],\
+		      other.data[1]-self.data[1])
+
+    def __mul__(self, other):
+	if isVec2(other):
+	    return reduce(lambda a,b: a+b,
+			  map(lambda a,b: a*b, self.data, other.data))
+	else:
+	    return Vec2(self.data[0]*other, self.data[1]*other)
+
+    def __rmul__(self, other):
+	if isVec2(other):
+	    return reduce(lambda a,b: a+b,
+			  map(lambda a,b: a*b, self.data, other.data))
+	else:
+	    return Vec2(other*self.data[0], other*self.data[1])
+
+    def __div__(self, other):
+	if isVec2(other):
+	    raise TypeError, "Can't divide by a vector"
+	else:
+	    return Vec2(_div(self.data[0],other), _div(self.data[1],other))
+	    
+    def __rdiv__(self, other):
+	raise TypeError, "Can't divide by a vector"
+
+    def __cmp__(self, other):
+	return cmp(self.data[0],other.data[0]) \
+	       or cmp(self.data[1],other.data[1])
+
+    def __getitem__(self, index):
+	return self.data[index]
+
+    def x(self):
+	return self.data[0]
+    def y(self):
+	return self.data[1]
+
+    def length(self):
+	return math.sqrt(self*self)
+
+    def normal(self):
+	len = self.length()
+	if len == 0:
+	    raise ZeroDivisionError, "Can't normalize a zero-length vector"
+	return self/len
+
+    #def cross(self, other):
+#	if not isVec2(other):
+#	    raise TypeError, "Cross product with non-vector"
+#	return Vec2(self.data[1]*other.data[2]-self.data[2]*other.data[1],
+#		      self.data[2]*other.data[0]-self.data[0]*other.data[2],
+#		      self.data[0]*other.data[1]-self.data[1]*other.data[0])
+
+    def angle(self, other):
+	if not isVec2(other):
+	    raise TypeError, "Angle between vector and non-vector"
+	cosa = (self*other)/(self.length()*other.length())
+	cosa = max(-1.,min(1.,cosa))
+	return math.acos(cosa)
+
+
+
+# Type check
+
+def isVec3(x):
+    return hasattr(x,'isVec3')
+
+def isVec2(x):
+    return hasattr(x,'isVec2')
+
+# "Correct" division for arbitrary number types
+
+def _div(a,b):
+    if type(a) == types.IntType and type(b) == types.IntType:
+	return float(a)/float(b)
+    else:
+	return a/b
+
+
+# Some useful constants
+
+ex = Vec3(1.,0.,0.)
+ey = Vec3(0.,1.,0.)
+ez = Vec3(0.,0.,1.)
diff --git a/source/blender/imbuf/intern/openexr/openexr_api.cpp b/source/blender/imbuf/intern/openexr/openexr_api.cpp
index fe352610a40..3e618a483e3 100644
--- a/source/blender/imbuf/intern/openexr/openexr_api.cpp
+++ b/source/blender/imbuf/intern/openexr/openexr_api.cpp
@@ -451,7 +451,7 @@ void IMB_exr_begin_write(void *handle, char *filename, int width, int height, in
 	openexr_header_compression(&header, compress);
 	/* header.lineOrder() = DECREASING_Y; this crashes in windows for file read! */
 	
-	header.insert ("BlenderMultiChannel", StringAttribute ("Blender V2.43"));
+	header.insert ("BlenderMultiChannel", StringAttribute ("Blender V2.43 and newer"));
 	
 	data->ofile = new OutputFile(filename, header);
 }
diff --git a/source/blender/include/BDR_drawaction.h b/source/blender/include/BDR_drawaction.h
index 91635123cb7..7cb0768e832 100644
--- a/source/blender/include/BDR_drawaction.h
+++ b/source/blender/include/BDR_drawaction.h
@@ -38,6 +38,7 @@ struct bAction;
 struct bActionGroup;
 struct Object;
 struct ListBase;
+struct bGPDlayer;
 
 /* ****************************** Base Structs ****************************** */
 
@@ -82,6 +83,7 @@ void draw_ipo_channel(struct gla2DDrawInfo *di, struct Ipo *ipo, float ypos);
 void draw_agroup_channel(struct gla2DDrawInfo *di, struct bActionGroup *agrp, float ypos);
 void draw_action_channel(struct gla2DDrawInfo *di, struct bAction *act, float ypos);
 void draw_object_channel(struct gla2DDrawInfo *di, struct Object *ob, float ypos);
+void draw_gpl_channel(struct gla2DDrawInfo *di, struct bGPDlayer *gpl, float ypos);
 
 /* Keydata Generation */
 void icu_to_keylist(struct IpoCurve *icu, ListBase *keys, ListBase *blocks, ActKeysInc *aki);
@@ -89,6 +91,7 @@ void ipo_to_keylist(struct Ipo *ipo, ListBase *keys, ListBase *blocks, ActKeysIn
 void agroup_to_keylist(struct bActionGroup *agrp, ListBase *keys, ListBase *blocks, ActKeysInc *aki);
 void action_to_keylist(struct bAction *act, ListBase *keys, ListBase *blocks, ActKeysInc *aki);
 void ob_to_keylist(struct Object *ob, ListBase *keys, ListBase *blocks, ActKeysInc *aki);
+void gpl_to_keylist(struct bGPDlayer *gpl, ListBase *keys, ListBase *blocks, ActKeysInc *aki);
 
 #endif  /*  BDR_DRAWACTION_H */
 
diff --git a/source/blender/include/BDR_gpencil.h b/source/blender/include/BDR_gpencil.h
new file mode 100644
index 00000000000..d0ebd096ecb
--- /dev/null
+++ b/source/blender/include/BDR_gpencil.h
@@ -0,0 +1,76 @@
+/**
+ * $Id: BDR_gpencil.h 14444 2008-04-16 22:40:48Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef BDR_GPENCIL_H
+#define BDR_GPENCIL_H
+
+struct ListBase;
+struct bScreen;
+struct ScrArea;
+struct View3D;
+struct SpaceNode;
+struct SpaceSeq;
+struct bGPdata;
+struct bGPDlayer;
+struct bGPDframe;
+
+/* ------------ Grease-Pencil API ------------------ */
+
+void free_gpencil_strokes(struct bGPDframe *gpf);
+void free_gpencil_frames(struct bGPDlayer *gpl);
+void free_gpencil_layers(struct ListBase *list);
+void free_gpencil_data(struct bGPdata *gpd);
+
+struct bGPDframe *gpencil_frame_addnew(struct bGPDlayer *gpl, int cframe);
+struct bGPDlayer *gpencil_layer_addnew(struct bGPdata *gpd);
+struct bGPdata *gpencil_data_addnew(void);
+
+struct bGPdata *gpencil_data_duplicate(struct bGPdata *gpd);
+
+struct bGPdata *gpencil_data_getactive(struct ScrArea *sa);
+short gpencil_data_setactive(struct ScrArea *sa, struct bGPdata *gpd);
+struct bGPdata *gpencil_data_getetime(struct bScreen *sc);
+void gpencil_data_setetime(struct bScreen *sc, struct bGPdata *gpd);
+
+void gpencil_frame_delete_laststroke(struct bGPDframe *gpf);
+
+struct bGPDframe *gpencil_layer_getframe(struct bGPDlayer *gpl, int cframe, short addnew);
+void gpencil_layer_delframe(struct bGPDlayer *gpl, struct bGPDframe *gpf);
+struct bGPDlayer *gpencil_layer_getactive(struct bGPdata *gpd);
+void gpencil_layer_setactive(struct bGPdata *gpd, struct bGPDlayer *active);
+void gpencil_layer_delactive(struct bGPdata *gpd);
+
+void gpencil_delete_actframe(struct bGPdata *gpd);
+void gpencil_delete_laststroke(struct bGPdata *gpd);
+
+void gpencil_delete_operation(short mode);
+void gpencil_delete_menu(void);
+
+//short gpencil_paint(short mousebutton);
+short gpencil_do_paint(struct ScrArea *sa);
+
+#endif /*  BDR_GPENCIL_H */
diff --git a/source/blender/include/BIF_drawgpencil.h b/source/blender/include/BIF_drawgpencil.h
new file mode 100644
index 00000000000..418446313df
--- /dev/null
+++ b/source/blender/include/BIF_drawgpencil.h
@@ -0,0 +1,44 @@
+/**
+ * $Id: BIF_drawgpencil.h 14444 2008-04-16 22:40:48Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef BIF_DRAWGPENCIL_H
+#define BIF_DRAWGPENCIL_H
+
+struct ScrArea;
+struct View3D;
+struct SpaceNode;
+struct SpaceSeq;
+struct bGPdata;
+struct uiBlock;
+
+short draw_gpencil_panel(struct uiBlock *block, struct bGPdata *gpd, struct ScrArea *sa); 
+
+void draw_gpencil_2dview(struct ScrArea *sa, short onlyv2d);
+void draw_gpencil_3dview(struct ScrArea *sa, short only3d);
+void draw_gpencil_oglrender(struct View3D *v3d, int winx, int winy);
+
+#endif /*  BIF_DRAWGPENCIL_H */ 
diff --git a/source/blender/include/BIF_editaction.h b/source/blender/include/BIF_editaction.h
index 2d751f56fc5..9f6751daeff 100644
--- a/source/blender/include/BIF_editaction.h
+++ b/source/blender/include/BIF_editaction.h
@@ -48,7 +48,8 @@ enum {
 	ACTTYPE_FILLIPO,
 	ACTTYPE_FILLCON,
 	ACTTYPE_IPO,
-	ACTTYPE_SHAPEKEY
+	ACTTYPE_SHAPEKEY,
+	ACTTYPE_GPLAYER
 };
 
 /* Macros for easier/more consistant state testing */
@@ -69,7 +70,10 @@ enum {
 #define EDITABLE_ICU(icu) ((icu->flag & IPO_PROTECT)==0)
 #define SEL_ICU(icu) (icu->flag & IPO_SELECT)
 
-#define NLA_ACTION_SCALED (G.saction->pin==0 && OBACT && OBACT->action)
+#define EDITABLE_GPL(gpl) ((gpl->flag & GP_LAYER_LOCKED)==0)
+#define SEL_GPL(gpl) ((gpl->flag & GP_LAYER_ACTIVE) || (gpl->flag & GP_LAYER_SELECT))
+
+#define NLA_ACTION_SCALED (G.saction->mode==SACTCONT_ACTION && G.saction->pin==0 && OBACT && OBACT->action)
 #define NLA_IPO_SCALED (OBACT && OBACT->action && G.sipo->pin==0 && G.sipo->actname)
 
 /* constants for setting ipo-interpolation type */
@@ -114,6 +118,8 @@ struct BWinEvent;
 struct Key;
 struct ListBase;
 struct TimeMarker;
+struct bGPdata;
+struct bGPDlayer;
 
 /* Key operations */
 void transform_action_keys(int mode, int dummy);
@@ -141,6 +147,7 @@ void paste_actdata(void);
 /* Group/Channel Operations */
 struct bActionGroup *get_active_actiongroup(struct bAction *act);
 void set_active_actiongroup(struct bAction *act, struct bActionGroup *agrp, short select);
+void actionbone_group_copycolors(struct bActionGroup *grp, short init_new);
 void verify_pchan2achan_grouping(struct bAction *act, struct bPose *pose, char name[]);
 void sync_pchan2achan_grouping(void); 
 void action_groups_group(short add_group);
@@ -166,6 +173,7 @@ void deselect_action_channels(short mode);
 void deselect_actionchannels(struct bAction *act, short mode);
 int select_channel(struct bAction *act, struct bActionChannel *achan, int selectmode);
 void select_actionchannel_by_name(struct bAction *act, char *name, int select);
+void select_action_group_channels(struct bAction *act, struct bActionGroup *agrp);
 void selectkeys_leftright (short leftright, short select_mode);
 
 /* Action Markers */
@@ -174,6 +182,24 @@ void action_add_localmarker(struct bAction *act, int frame);
 void action_rename_localmarker(struct bAction *act);
 void action_remove_localmarkers(struct bAction *act);
 
+/* Grease-Pencil Data */
+void gplayer_make_cfra_list(struct bGPDlayer *gpl, ListBase *elems, short onlysel);
+
+void deselect_gpencil_layers(struct bGPdata *gpd, short select_mode);
+
+short is_gplayer_frame_selected(struct bGPDlayer *gpl);
+void set_gplayer_frame_selection(struct bGPDlayer *gpl, short mode);
+void select_gpencil_frames(struct bGPDlayer *gpl, short select_mode);
+void select_gpencil_frame(struct bGPDlayer *gpl, int selx, short select_mode);
+void borderselect_gplayer_frames(struct bGPDlayer *gpl, float min, float max, short select_mode);
+
+void delete_gpencil_layers(void);
+void delete_gplayer_frames(struct bGPDlayer *gpl);
+void duplicate_gplayer_frames(struct bGPDlayer *gpd);
+
+void snap_gplayer_frames(struct bGPDlayer *gpl, short mode);
+void mirror_gplayer_frames(struct bGPDlayer *gpl, short mode);
+
 /* ShapeKey stuff */
 struct Key *get_action_mesh_key(void);
 int get_nearest_key_num(struct Key *key, short *mval, float *x);
diff --git a/source/blender/include/BIF_resources.h b/source/blender/include/BIF_resources.h
index e6cbe7bb69a..df514190270 100644
--- a/source/blender/include/BIF_resources.h
+++ b/source/blender/include/BIF_resources.h
@@ -591,6 +591,9 @@ void	BIF_load_ui_colors		(void);
 char 	*BIF_ThemeGetColorPtr(struct bTheme *btheme, int spacetype, int colorid);
 char 	*BIF_ThemeColorsPup(int spacetype);
 
+/* only for Bone Color sets */
+char *BIF_ThemeColorSetsPup(short inc_custom);
+
 
 void	BIF_def_color			(BIFColorID colorid, unsigned char r, unsigned char g, unsigned char b);
 
diff --git a/source/blender/include/BIF_space.h b/source/blender/include/BIF_space.h
index 37be4a9eafc..4b2b8e14bb6 100644
--- a/source/blender/include/BIF_space.h
+++ b/source/blender/include/BIF_space.h
@@ -53,6 +53,7 @@ struct SpaceOops;
 #define VIEW3D_HANDLER_PREVIEW		4
 #define VIEW3D_HANDLER_MULTIRES         5
 #define VIEW3D_HANDLER_TRANSFORM	6
+#define VIEW3D_HANDLER_GREASEPENCIL 7
 
 /* ipo handler codes */
 #define IPO_HANDLER_PROPERTIES	20
@@ -73,11 +74,15 @@ struct SpaceOops;
 #define NLA_HANDLER_PROPERTIES	50
 
 /* sequence handler codes */
-#define SEQ_HANDLER_PROPERTIES	60
+#define SEQ_HANDLER_PROPERTIES		60
+#define SEQ_HANDLER_GREASEPENCIL 	61
 
 /* imasel handler codes */
 #define IMASEL_HANDLER_IMAGE	70
 
+/* nodes handler codes */
+#define NODES_HANDLER_GREASEPENCIL		80
+
 /* theme codes */
 #define B_ADD_THEME 	3301
 #define B_DEL_THEME 	3302
@@ -145,3 +150,4 @@ extern		 void mainwindow_close(void);
 
 #endif
 
+
diff --git a/source/blender/include/BSE_editaction_types.h b/source/blender/include/BSE_editaction_types.h
index c531383accc..be210415973 100644
--- a/source/blender/include/BSE_editaction_types.h
+++ b/source/blender/include/BSE_editaction_types.h
@@ -38,7 +38,8 @@ typedef enum ALE_KEYTYPE {
 	ALE_NONE = 0,
 	ALE_IPO,	
 	ALE_ICU,
-	ALE_GROUP	
+	ALE_GROUP,
+	ALE_GPFRAME,
 } ALE_KEYTYPE;
 
 /* This struct defines a structure used for quick access */
@@ -78,7 +79,8 @@ typedef enum ACTFILTER_FLAGS {
 typedef enum ACTCONT_TYPES {
 	ACTCONT_NONE = 0,
 	ACTCONT_ACTION,
-	ACTCONT_SHAPEKEY
+	ACTCONT_SHAPEKEY,
+	ACTCONT_GPENCIL
 } ACTCONT_TYPES;
 
 #endif
diff --git a/source/blender/include/blendef.h b/source/blender/include/blendef.h
index a798224b35b..6f8b94d7cd1 100644
--- a/source/blender/include/blendef.h
+++ b/source/blender/include/blendef.h
@@ -409,6 +409,12 @@
 #define B_ACTCOPYKEYS		710
 #define B_ACTPASTEKEYS		711
 
+#define B_ACTCUSTCOLORS		712
+#define B_ACTCOLSSELECTOR	713
+#define B_ACTGRP_SELALL		714
+#define B_ACTGRP_ADDTOSELF	715
+#define B_ACTGRP_UNGROUP	716
+
 /* TIME: 751 - 800 */
 #define B_TL_REW		751
 #define B_TL_PLAY		752
diff --git a/source/blender/include/transform.h b/source/blender/include/transform.h
index 4e3b80134f9..720b856a149 100644
--- a/source/blender/include/transform.h
+++ b/source/blender/include/transform.h
@@ -397,6 +397,7 @@ int Align(TransInfo *t, short mval[2]);
 
 /*********************** transform_conversions.c ********** */
 struct ListBase;
+void flushTransGPactionData(TransInfo *t);
 void flushTransIpoData(TransInfo *t);
 void flushTransUVs(TransInfo *t);
 void flushTransParticles(TransInfo *t);
diff --git a/source/blender/makesdna/DNA_action_types.h b/source/blender/makesdna/DNA_action_types.h
index 18d2a1cb6f3..d7969a7379b 100644
--- a/source/blender/makesdna/DNA_action_types.h
+++ b/source/blender/makesdna/DNA_action_types.h
@@ -32,6 +32,7 @@
 
 #include "DNA_listBase.h"
 #include "DNA_ID.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_view2d_types.h"
 #include "DNA_userdef_types.h"
 
@@ -183,8 +184,11 @@ typedef struct SpaceAction {
 	View2D v2d;	
 	
 	bAction		*action;		/* the currently active action */
-	short flag, autosnap;		/* flag: bitmapped settings; autosnap: automatic keyframe snapping mode */
-	short pin, actnr, lock;		/* pin: keep showing current action; actnr: used for finding chosen action from menu; lock: lock time to other windows */
+	bGPdata 	*gpd;		/* the currently active gpencil block (for editing) */
+	
+	char  mode, autosnap;		/* mode: editing context; autosnap: automatic keyframe snapping mode   */
+	short flag, actnr; 			/* flag: bitmapped settings; */
+	short pin, lock;			/* pin: keep showing current action; actnr: used for finding chosen action from menu; lock: lock time to other windows */
 	short actwidth;				/* width of the left-hand side name panel (in pixels?) */
 	float timeslide;			/* for Time-Slide transform mode drawing - current frame? */
 } SpaceAction;
@@ -238,6 +242,18 @@ typedef enum SACTION_FLAG {
 	SACTION_NODRAWGCOLORS = (1<<7)
 } SACTION_FLAG;	
 
+/* SpaceAction Mode Settings */
+typedef enum SACTCONT_MODES {
+		/* action (default) */
+	SACTCONT_ACTION	= 0,
+		/* editing of shapekey's IPO block */
+	SACTCONT_SHAPEKEY,
+		/* editing of gpencil data */
+	SACTCONT_GPENCIL,
+		/* dopesheet (unimplemented... future idea?) */
+	SACTCONT_DOPESHEET
+} SACTCONTEXT_MODES;
+
 /* SpaceAction AutoSnap Settings (also used by SpaceNLA) */
 typedef enum SACTSNAP_MODES {
 		/* no auto-snap */
diff --git a/source/blender/makesdna/DNA_actuator_types.h b/source/blender/makesdna/DNA_actuator_types.h
index a467722e8e1..ac9761f165d 100644
--- a/source/blender/makesdna/DNA_actuator_types.h
+++ b/source/blender/makesdna/DNA_actuator_types.h
@@ -196,9 +196,7 @@ typedef struct bVisibilityActuator {
 } bVisibilityActuator;
 
 typedef struct bTwoDFilterActuator{
-	char pad[2];
-	/* bitwise flag for enabling or disabling depth(bit 0) and luminance(bit 1) */
-	short texture_flag;
+	char pad[4];
 	/* Tells what type of 2D Filter */
 	short type;
 	/* (flag == 0) means 2D filter is activate and
diff --git a/source/blender/makesdna/DNA_gpencil_types.h b/source/blender/makesdna/DNA_gpencil_types.h
new file mode 100644
index 00000000000..eafd886981b
--- /dev/null
+++ b/source/blender/makesdna/DNA_gpencil_types.h
@@ -0,0 +1,141 @@
+/**
+ * $Id: DNA_gpencil_types.h 8768 2006-11-07 00:10:37Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation.
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef DNA_GPENCIL_TYPES_H
+#define DNA_GPENCIL_TYPES_H
+
+#include "DNA_listBase.h"
+#include "DNA_ID.h"
+
+/* Grease-Pencil Annotations - 'Stroke Point'
+ *	-> Coordinates may either be 2d or 3d depending on settings at the time
+ * 	-> Coordinates of point on stroke, in proportions of window size
+ *		(i.e. n/1000). This assumes that the bottom-left corner is (0,0)
+ */
+typedef struct bGPDspoint {
+	float x, y, z;			/* co-ordinates of point (usually 2d, but can be 3d as well) */				
+	float pressure;			/* pressure of input device (from 0 to 1) at this point */
+} bGPDspoint;
+
+/* Grease-Pencil Annotations - 'Stroke'
+ * 	-> A stroke represents a (simplified version) of the curve
+ *	   drawn by the user in one 'mousedown'->'mouseup' operation
+ */
+typedef struct bGPDstroke {
+	struct bGPDstroke *next, *prev;
+	
+	bGPDspoint *points;		/* array of data-points for stroke */
+	int totpoints;			/* number of data-points in array */
+	
+	short thickness;		/* thickness of stroke (currently not used) */	
+	short flag;				/* various settings about this stroke */
+} bGPDstroke;
+
+/* bGPDstroke->flag */
+	/* stroke is in 3d-space */
+#define GP_STROKE_3DSPACE		(1<<0)
+	/* stroke is in 2d-space */
+#define GP_STROKE_2DSPACE		(1<<1)
+
+
+/* Grease-Pencil Annotations - 'Frame'
+ *	-> Acts as storage for the 'image' formed by strokes
+ */
+typedef struct bGPDframe {
+	struct bGPDframe *next, *prev;
+	
+	ListBase strokes;	/* list of the simplified 'strokes' that make up the frame's data */
+	
+	int framenum;		/* frame number of this frame */
+	int flag;			/* temp settings */
+} bGPDframe;
+
+/* bGPDframe->flag */	
+	/* frame is being painted on */
+#define GP_FRAME_PAINT		(1<<0)
+	/* for editing in Action Editor */
+#define GP_FRAME_SELECT		(1<<1)
+
+
+/* Grease-Pencil Annotations - 'Layer' */
+typedef struct bGPDlayer {
+	struct bGPDlayer *next, *prev;
+	
+	ListBase frames;		/* list of annotations to display for frames (bGPDframe list) */
+	bGPDframe *actframe;	/* active frame (should be the frame that is currently being displayed) */
+	
+	int flag;				/* settings for layer */		
+	short thickness;		/* current thickness to apply to strokes */
+	short gstep;			/* max number of frames between active and ghost to show (0=only those on either side) */
+	
+	float color[4];			/* color that should be used to draw all the strokes in this layer */
+	
+	char info[128];			/* optional reference info about this layer (i.e. "director's comments, 12/3") */
+} bGPDlayer;
+
+/* bGPDlayer->flag */
+	/* don't display layer */
+#define GP_LAYER_HIDE		(1<<0)
+	/* protected from further editing */
+#define GP_LAYER_LOCKED		(1<<1)	
+	/* layer is 'active' layer being edited */
+#define GP_LAYER_ACTIVE		(1<<2)
+	/* draw points of stroke for debugging purposes */
+#define GP_LAYER_DRAWDEBUG 	(1<<3)
+	/* do onionskinning */
+#define GP_LAYER_ONIONSKIN	(1<<4)
+	/* for editing in Action Editor */
+#define GP_LAYER_SELECT		(1<<5)
+
+
+/* Grease-Pencil Annotations - 'DataBlock' */
+typedef struct bGPdata {
+	/* saved Grease-Pencil data */
+	ListBase layers;		/* bGPDlayers */
+	int flag;				/* settings for this datablock */
+	
+	/* not-saved stroke buffer data (only used during paint-session) 
+	 * 	- buffer must be initialised before use, but freed after 
+	 *	  whole paint operation is over
+	 */
+	short sbuffer_size;			/* number of elements currently in cache */
+	short sbuffer_sflag;		/* flags for stroke that cache represents */
+	bGPDspoint *sbuffer;		/* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
+} bGPdata;
+
+/* bGPdata->flag */
+	/* draw this datablock's data (not used) */
+#define GP_DATA_DISP		(1<<0)
+	/* show debugging info in viewport (i.e. status print) */
+#define GP_DATA_DISPINFO	(1<<1)
+	/* is the block being shown in Action Editor */
+#define GP_DATA_EDITTIME	(1<<2)
+	/* is the block overriding all clicks? */
+#define GP_DATA_EDITPAINT	(1<<3)
+	/* new strokes are added in viewport space */
+#define GP_DATA_VIEWALIGN	(1<<4)
+
+#endif /*  DNA_GPENCIL_TYPES_H */
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index 75affbfa7f5..4818e693657 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -134,6 +134,7 @@ typedef struct SceneRenderLayer {
 #define SCE_LAY_EDGE	8
 #define SCE_LAY_SKY		16
 #define SCE_LAY_STRAND	32
+#define SCE_LAY_FRS		64
 	/* flags between 32 and 0x8000 are set to 1 already, for future options */
 
 #define SCE_LAY_ALL_Z		0x8000
@@ -571,6 +572,7 @@ typedef struct Scene {
 #define R_ORTHO			0x0008
 #define R_ENVMAP		0x0010
 #define R_EDGE			0x0020
+#define R_EDGE_FRS		0x2000000 // will replace R_EDGE
 #define R_FIELDS		0x0040
 #define R_FIELDSTILL	0x0080
 #define R_RADIO			0x0100
@@ -611,6 +613,7 @@ typedef struct Scene {
 /* yafray: renderer flag (not only exclusive to yafray) */
 #define R_INTERN	0
 #define R_YAFRAY	1
+#define R_FREESTYLE	2
 
 /* scemode (int now) */
 #define R_DOSEQ				0x0001
diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h
index bc30a12ff27..a8694dfb7f5 100644
--- a/source/blender/makesdna/DNA_space_types.h
+++ b/source/blender/makesdna/DNA_space_types.h
@@ -50,6 +50,7 @@ struct RenderInfo;
 struct bNodeTree;
 struct uiBlock;
 struct FileList;
+struct bGPdata;
 
 	/**
 	 * The base structure all the other spaces
@@ -150,6 +151,8 @@ typedef struct SpaceSeq {
 	short zebra;
 	int flag;
 	float zoom;
+	
+	struct bGPdata *gpd;		/* grease-pencil data */
 } SpaceSeq;
 
 typedef struct SpaceFile {
@@ -339,6 +342,8 @@ typedef struct SpaceNode {
 	float blockscale;
 	struct ScrArea *area;
 	
+	short blockhandler[8];
+	
 	View2D v2d;
 	
 	struct ID *id, *from;		/* context, no need to save in file? well... pinning... */
@@ -351,11 +356,13 @@ typedef struct SpaceNode {
 	struct bNodeTree *nodetree, *edittree;
 	int treetype, pad;			/* treetype: as same nodetree->type */
 	
+	struct bGPdata *gpd;		/* grease-pencil data */
 } SpaceNode;
 
 /* snode->flag */
 #define SNODE_DO_PREVIEW	1
 #define SNODE_BACKDRAW		2
+#define SNODE_DISPGP		4
 
 typedef struct SpaceImaSel {
 	SpaceLink *next, *prev;
@@ -657,6 +664,7 @@ typedef struct SpaceImaSel {
 #define SEQ_MARKER_TRANS 2
 #define SEQ_DRAW_COLOR_SEPERATED     4
 #define SEQ_DRAW_SAFE_MARGINS        8
+#define SEQ_DRAW_GPENCIL			16
 
 /* space types, moved from DNA_screen_types.h */
 enum {
diff --git a/source/blender/makesdna/DNA_userdef_types.h b/source/blender/makesdna/DNA_userdef_types.h
index 3de5b0ff5ba..cd1c047dac9 100644
--- a/source/blender/makesdna/DNA_userdef_types.h
+++ b/source/blender/makesdna/DNA_userdef_types.h
@@ -116,6 +116,7 @@ typedef struct ThemeWireColor {
 
 /* flags for ThemeWireColor */
 #define TH_WIRECOLOR_CONSTCOLS	(1<<0)
+#define TH_WIRECOLOR_TEXTCOLS	(1<<1)
 
 /* A theme */
 typedef struct bTheme {
diff --git a/source/blender/makesdna/DNA_view3d_types.h b/source/blender/makesdna/DNA_view3d_types.h
index c21d629be83..135272b9ac2 100644
--- a/source/blender/makesdna/DNA_view3d_types.h
+++ b/source/blender/makesdna/DNA_view3d_types.h
@@ -40,6 +40,7 @@ struct Base;
 struct BoundBox;
 struct RenderInfo;
 struct RetopoViewData;
+struct bGPdata;
 
 /* This is needed to not let VC choke on near and far... old
  * proprietary MS extensions... */
@@ -53,9 +54,12 @@ struct RetopoViewData;
 #include "DNA_listBase.h"
 #include "DNA_image_types.h"
 
+/* ******************************** */
+
 /* The near/far thing is a Win EXCEPTION. Thus, leave near/far in the
  * code, and patch for windows. */
-
+ 
+/* Background Picture in 3D-View */
 typedef struct BGpic {
     struct Image *ima;
 	struct ImageUser iuser;
@@ -63,6 +67,9 @@ typedef struct BGpic {
     short xim, yim;
 } BGpic;
 
+/* ********************************* */
+
+/* 3D ViewPort Struct */
 typedef struct View3D {
 	struct SpaceLink *next, *prev;
 	int spacetype;
@@ -135,9 +142,10 @@ typedef struct View3D {
 	char ndoffilter;		/*filter for 6DOF devices 0 normal, 1 dominant */
 	
 	void *properties_storage;	/* Nkey panel stores stuff here, not in file */
-
+	struct bGPdata *gpd;		/* Grease-Pencil Data (annotation layers) */
 } View3D;
 
+
 /* View3D->flag (short) */
 #define V3D_MODE			(16+32+64+128+256+512)
 #define V3D_DISPIMAGE		1
@@ -158,10 +166,12 @@ typedef struct View3D {
 #define V3D_DRAW_CENTERS	32768
 
 /* View3d->flag2 (short) */
+#define V3D_MODE2			(32)
 #define V3D_OPP_DIRECTION_NAME	1
 #define V3D_FLYMODE				2
 #define V3D_DEPRECATED			4 /* V3D_TRANSFORM_SNAP, moved to a scene setting */
 #define V3D_SOLID_TEX			8
+#define V3D_DISPGP				16
 
 /* View3D->around */
 #define V3D_CENTER		 0
@@ -203,3 +213,4 @@ typedef struct View3D {
 
 #endif
 
+
diff --git a/source/blender/makesdna/intern/makesdna.c b/source/blender/makesdna/intern/makesdna.c
index 83f4e633fa1..3818d66b39c 100644
--- a/source/blender/makesdna/intern/makesdna.c
+++ b/source/blender/makesdna/intern/makesdna.c
@@ -126,6 +126,7 @@ char *includefiles[] = {
 	"DNA_customdata_types.h",
 	"DNA_particle_types.h",
 	"DNA_cloth_types.h",
+	"DNA_gpencil_types.h",
 	// if you add files here, please add them at the end
 	// of makesdna.c (this file) as well
 
@@ -1147,4 +1148,5 @@ int main(int argc, char ** argv)
 #include "DNA_customdata_types.h"
 #include "DNA_particle_types.h"
 #include "DNA_cloth_types.h"
+#include "DNA_gpencil_types.h"
 /* end of list */
diff --git a/source/blender/python/SConscript b/source/blender/python/SConscript
index 481fdcbe13e..8612a9d6ca9 100644
--- a/source/blender/python/SConscript
+++ b/source/blender/python/SConscript
@@ -4,7 +4,7 @@ Import ('env')
 sources = Split('BPY_interface.c BPY_menus.c') + env.Glob('api2_2x/*.c')
 
 incs = 'api2_2x ../blenkernel ../nodes ../blenlib ../blenloader'
-incs += ' ../render/extern/include ../radiosity/extern/include'
+incs += ' ../render/extern/include ../radiosity/extern/include ../freestyle/intern/python'
 incs += ' ../makesdna #intern/guardedalloc #intern/bmfont ../imbuf ../include'
 incs += ' ' + env['BF_PYTHON_INC']
 incs += ' ' + env['BF_OPENGL_INC']
diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c
index d8385c1d660..71675ade605 100644
--- a/source/blender/python/api2_2x/Blender.c
+++ b/source/blender/python/api2_2x/Blender.c
@@ -97,6 +97,7 @@ struct ID; /*keep me up here */
 #include "World.h"
 #include "Types.h"
 #include "Particle.h"
+#include "Freestyle.h"
 
 /**********************************************************/
 /* Python API function prototypes for the Blender module.	*/
@@ -708,7 +709,7 @@ static PyObject *Blender_Save( PyObject * self, PyObject * args )
 					      "expected filename and optional int (overwrite flag) as arguments" );
 
 	for( li = G.main->library.first; li; li = li->id.next ) {
-		if( BLI_streq( li->name, fname ) ) {
+		if( li->parent==NULL && BLI_streq( li->name, fname ) ) {
 			return EXPP_ReturnPyObjError( PyExc_AttributeError,
 						      "cannot overwrite used library" );
 		}
@@ -1095,4 +1096,5 @@ void M_Blender_Init(void)
 	PyDict_SetItemString(dict, "Window", Window_Init());
 	PyDict_SetItemString(dict, "World", World_Init());
 
+	PyDict_SetItemString(dict, "Freestyle", Freestyle_Init());
 }
diff --git a/source/blender/python/api2_2x/Library.c b/source/blender/python/api2_2x/Library.c
index 799735c2062..468263c4208 100644
--- a/source/blender/python/api2_2x/Library.c
+++ b/source/blender/python/api2_2x/Library.c
@@ -1135,9 +1135,78 @@ static PyObject *M_Library_Load(PyObject *self, PyObject * args)
 	return (PyObject *)lib;
 }
 
+static PyObject *M_Library_GetPaths(PyObject *self, PyObject * args)
+{	
+	PyObject *list;
+	PyObject *name;
+	int type=0;
+	Library *lib;
+	
+	if( !PyArg_ParseTuple( args, "|i", &type ) || type < 0 || type > 2 ) {
+		return EXPP_ReturnPyObjError( PyExc_TypeError,
+			"expected an int between 0 and 2." );
+	}
+	
+	list = PyList_New(0);
+	
+	for(lib= G.main->library.first; lib; lib= lib->id.next) {
+		if (type==0) {
+			/* any type is ok */
+		} else if (type==1 && lib->parent == 0) {
+			/* only direct linked */
+		} else if (type==2 && lib->parent != 0) {
+			/* only indirect */
+		} else {
+			continue; /* incompatible type */
+		}
+		
+		name = PyString_FromString(lib->name);
+		PyList_Append(list, name);
+		Py_DECREF(name);
+	}
+	return list;
+}
+
+static PyObject *M_Library_ReplacePath(PyObject *self, PyObject * args)
+{
+	char *name_from, *name_to;
+	Library *lib;
+	
+	if( !PyArg_ParseTuple( args, "ss", &name_from, &name_to )) {
+		return EXPP_ReturnPyObjError( PyExc_TypeError,
+			"expected the name of a library path" );
+	}
+	
+	for(lib= G.main->library.first; lib; lib= lib->id.next) {
+		if (strcmp(lib->name, name_from)==0) {
+			if (lib->parent) {
+				return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+					"path is indirectly linked, cannot be changed." );
+			}
+			
+			if (strlen(name_to) > sizeof(lib->name)) {
+				return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+					"string length too long, cannot set path." );
+			}
+			
+			strcpy(lib->name, name_to);
+			Py_RETURN_NONE;
+		}
+	}
+	
+	return EXPP_ReturnPyObjError( PyExc_ValueError,
+		"path given does not exist as a library" );
+}
+
+
+
 static struct PyMethodDef M_Library_methods[] = {
 	{"load", (PyCFunction)M_Library_Load, METH_VARARGS,
 	"(string) - declare a .blend file for use as a library"},
+	{"paths", (PyCFunction)M_Library_GetPaths, METH_VARARGS,
+	"(type) - return a list of library paths, type 0 for all, 1 only direct links, 2 only indirect links"},
+	{"replace", (PyCFunction)M_Library_ReplacePath, METH_VARARGS,
+	"(from, to) - replace the path of an existing, directly linked library."},
 	{NULL, NULL, 0, NULL}
 };
 
diff --git a/source/blender/python/api2_2x/Particle.c b/source/blender/python/api2_2x/Particle.c
index 95de9757b87..2c2e724129e 100644
--- a/source/blender/python/api2_2x/Particle.c
+++ b/source/blender/python/api2_2x/Particle.c
@@ -40,6 +40,7 @@
 #include "BKE_material.h"
 #include "BKE_utildefines.h"
 #include "BKE_pointcache.h"
+#include "BKE_DerivedMesh.h"
 #include "BIF_editparticle.h"
 #include "BIF_space.h"
 #include "blendef.h"
@@ -799,22 +800,27 @@ static PyObject *Part_freeEdit( BPy_PartSys * self, PyObject * args ){
 	Py_RETURN_NONE;
 }
 
-static PyObject *Part_GetLoc( BPy_PartSys * self, PyObject * args ){
+static PyObject *Part_GetLoc( BPy_PartSys * self, PyObject * args )
+{
 	ParticleSystem *psys = 0L;
 	Object *ob = 0L;
 	PyObject *partlist,*seglist;
-	PyObject* loc = 0L;
 	ParticleCacheKey **cache,*path;
+	PyObject* loc = 0L;
 	ParticleKey state;
-	float cfra=bsystem_time(ob,(float)CFRA,0.0);
+	DerivedMesh* dm;
+	float cfra;
 	int i,j,k;
+	float vm[4][4],wm[4][4];
 	int	childexists = 0;
 	int all = 0;
 	int id = 0;
 
+	cfra = bsystem_time(ob,(float)CFRA,0.0);
+
 	if( !PyArg_ParseTuple( args, "|ii", &all,&id ) )
 		return EXPP_ReturnPyObjError( PyExc_TypeError,
-				"expected one optional integer as argument" );
+				"expected two optional integers as arguments" );
 
 	psys = self->psys;
 	ob = self->object;
@@ -822,88 +828,118 @@ static PyObject *Part_GetLoc( BPy_PartSys * self, PyObject * args ){
 	if (!ob || !psys)
 		Py_RETURN_NONE;
 
-	if (psys->part->type == 2){
-		cache=psys->pathcache;
+	G.rendering = 1;
 
-		/* little hack to calculate hair steps in render mode */
-		psys->renderdata = (void*)(int)1;
+	/* Just to create a valid rendering context */
+	psys_render_set(ob,psys,vm,wm,0,0,0);
 
-		psys_cache_paths(ob, psys, cfra, 1);
+	dm = mesh_create_derived_render(ob,CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
+	dm->release(dm);
 
-		psys->renderdata = NULL;
+	if ( !psys_check_enabled(ob,psys) ){
+		G.rendering = 0;
+		psys_render_restore(ob,psys);
+		Particle_Recalc(self,1);
+		Py_RETURN_NONE;
+	}
 
-		partlist = PyList_New( 0 );
-		if( !partlist )
-			return EXPP_ReturnPyObjError( PyExc_MemoryError, "PyList() failed" );
+	partlist = PyList_New( 0 );
+	if( !partlist ){
+		PyErr_SetString( PyExc_MemoryError, "PyList_New() failed" );
+		goto error;
+	}
 
-		for(i = 0; i < psys->totpart; i++){
-			path=cache[i];
-			seglist = PyList_New( 0 );
-			k = path->steps+1;
-			for( j = 0; j < k ; j++){
-				loc = PyTuple_New(3);
-
-				PyTuple_SetItem(loc,0,PyFloat_FromDouble((double)path->co[0]));
-				PyTuple_SetItem(loc,1,PyFloat_FromDouble((double)path->co[1]));
-				PyTuple_SetItem(loc,2,PyFloat_FromDouble((double)path->co[2]));
-
-				if ( (PyList_Append(seglist,loc) < 0) ){
-					Py_DECREF(seglist);
-					Py_DECREF(partlist);
-					Py_XDECREF(loc);
-					return EXPP_ReturnPyObjError( PyExc_RuntimeError,
-							"Couldn't append item to PyList" );
+	if (psys->part->type == PART_HAIR){
+		cache = psys->pathcache;
+
+		if ( ((self->psys->part->draw & PART_DRAW_PARENT) && (self->psys->part->childtype != 0)) || (self->psys->part->childtype == 0) ){
+
+			for(i = 0; i < psys->totpart; i++){
+				seglist = PyList_New( 0 );
+				if (!seglist){
+					PyErr_SetString( PyExc_MemoryError,
+							"PyList_New() failed" );
+					goto error;
+				}
+
+				path=cache[i];
+				k = path->steps+1;
+				for( j = 0; j < k ; j++, path++){
+					loc = Py_BuildValue("(fff)",(double)path->co[0],
+							(double)path->co[1], (double)path->co[2]);
+
+					if (!loc){
+						PyErr_SetString( PyExc_RuntimeError,
+								"Couldn't build tuple" );
+						goto error;
+					}
+
+					if ( (PyList_Append(seglist,loc) < 0) ){
+						PyErr_SetString( PyExc_RuntimeError,
+								"Couldn't append item to PyList" );
+						goto error;
+					}
+					Py_DECREF(loc); /* PyList_Append increfs */
+					loc = NULL;
 				}
-				Py_DECREF(loc); /* PyList_Append increfs */
-				path++;
-			}
 
-			if ( PyList_Append(partlist,seglist) < 0 ){
-				Py_DECREF(seglist);
-				Py_DECREF(partlist);
-				return EXPP_ReturnPyObjError( PyExc_RuntimeError,
-						"Couldn't append item to PyList" );		
+				if ( PyList_Append(partlist,seglist) < 0 ){
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't append item to PyList" );		
+					goto error;
+				}
+				Py_DECREF(seglist); /* PyList_Append increfs */
+				seglist = NULL;
 			}
-			Py_DECREF(seglist); /* PyList_Append increfs */
 		}
 
 		cache=psys->childcache;
 
 		for(i = 0; i < psys->totchild; i++){
-			path=cache[i];
 			seglist = PyList_New( 0 );
-			k = path->steps+1;
-			for( j = 0; j < k ; j++){
-				loc = PyTuple_New(3);
+			if (!seglist){
+				PyErr_SetString( PyExc_MemoryError,
+						"PyList_New() failed" );
+				goto error;
+			}
 
-				PyTuple_SetItem(loc,0,PyFloat_FromDouble((double)path->co[0]));
-				PyTuple_SetItem(loc,1,PyFloat_FromDouble((double)path->co[1]));
-				PyTuple_SetItem(loc,2,PyFloat_FromDouble((double)path->co[2]));
+			path=cache[i];
+			k = path->steps+1;
+			for( j = 0; j < k ; j++, path++ ){
+				loc = Py_BuildValue("(fff)",(double)path->co[0],
+						(double)path->co[1], (double)path->co[2]);
+
+				if (!loc){
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't build tuple" );
+					goto error;
+				}
 
 				if ( PyList_Append(seglist,loc) < 0){
-					Py_DECREF(partlist);
-					Py_XDECREF(loc);
-					return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+					PyErr_SetString( PyExc_RuntimeError,
 							"Couldn't append item to PyList" );
+					goto error;
 				}
 				Py_DECREF(loc);/* PyList_Append increfs */
-				path++;
+				loc = NULL;
 			}
 
 			if ( PyList_Append(partlist,seglist) < 0){
-				Py_DECREF(partlist);
-				Py_XDECREF(loc);
-				return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+				PyErr_SetString( PyExc_RuntimeError,
 						"Couldn't append item to PyList" );	
+				goto error;
 			}
 			Py_DECREF(seglist); /* PyList_Append increfs */
+			seglist = NULL;
 		}
-		
 	} else {
 		int init;
-		partlist = PyList_New( 0 );
-		if( !partlist )
-			return EXPP_ReturnPyObjError( PyExc_MemoryError, "PyList() failed" );
+		char *fmt = NULL;
+
+		if(id)
+			fmt = "(fffi)";
+		else
+			fmt = "(fff)";
 
 		if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
 			childexists = 1;
@@ -919,55 +955,67 @@ static PyObject *Part_GetLoc( BPy_PartSys * self, PyObject * args ){
 				init = 1;
 
 			if (init){
-				if (!id)
-					loc = PyTuple_New(3);
-				else
-					loc = PyTuple_New(4);
-				PyTuple_SetItem(loc,0,PyFloat_FromDouble((double)state.co[0]));
-				PyTuple_SetItem(loc,1,PyFloat_FromDouble((double)state.co[1]));
-				PyTuple_SetItem(loc,2,PyFloat_FromDouble((double)state.co[2]));
-				if (id)
-					PyTuple_SetItem(loc,3,PyInt_FromLong(i));
+				loc = Py_BuildValue(fmt,(double)state.co[0],
+						(double)state.co[1], (double)state.co[2],i);
+				
+				if (!loc){
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't build tuple" );
+					goto error;
+				}
 
 				if ( PyList_Append(partlist,loc) < 0 ){
-					Py_DECREF(partlist);
-					Py_XDECREF(loc);
-					return EXPP_ReturnPyObjError( PyExc_RuntimeError,
-								"Couldn't append item to PyList" );
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't append item to PyList" );
+					goto error;
 				}
-				Py_DECREF(loc);/* PyList_Append increfs */
-			}
-			else {
-				if ( all ){
-					if ( PyList_Append(partlist,Py_None) < 0 ){
-						Py_DECREF(partlist);
-						return EXPP_ReturnPyObjError( PyExc_RuntimeError,
-									"Couldn't append item to PyList" );
-					}
-					Py_DECREF(Py_None); /* PyList_Append increfs */
+				Py_DECREF(loc);
+				loc = NULL;
+			} else {
+				if ( all && PyList_Append(partlist,Py_None) < 0 ){
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't append item to PyList" );
+					goto error;
 				}
 			}
 		}
 	}
+
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
 	return partlist;
+
+error:
+	Py_XDECREF(partlist);
+	Py_XDECREF(seglist);
+	Py_XDECREF(loc);
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
+	return NULL;
 }
 
-static PyObject *Part_GetRot( BPy_PartSys * self, PyObject * args ){
+static PyObject *Part_GetRot( BPy_PartSys * self, PyObject * args )
+{
 	ParticleSystem *psys = 0L;
 	Object *ob = 0L;
 	PyObject *partlist = 0L;
 	PyObject* loc = 0L;
 	ParticleKey state;
+	DerivedMesh* dm;
+	float vm[4][4],wm[4][4];
 	int i;
 	int childexists = 0;
 	int all = 0;
 	int id = 0;
+    char *fmt = NULL;
 
 	float cfra=bsystem_time(ob,(float)CFRA,0.0);
 
 	if( !PyArg_ParseTuple( args, "|ii", &all, &id ) )
 		return EXPP_ReturnPyObjError( PyExc_TypeError,
-				"expected one optional integer as argument" );
+				"expected two optional integers as arguments" );
 
 	psys = self->psys;
 	ob = self->object;
@@ -975,63 +1023,105 @@ static PyObject *Part_GetRot( BPy_PartSys * self, PyObject * args ){
 	if (!ob || !psys)
 		Py_RETURN_NONE;
 
-	if (psys->part->type != 2){
+	G.rendering = 1;
+
+	/* Just to create a valid rendering context */
+	psys_render_set(ob,psys,vm,wm,0,0,0);
+
+	dm = mesh_create_derived_render(ob,CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
+	dm->release(dm);
+
+	if ( !psys_check_enabled(ob,psys) ){
+		G.rendering = 0;
+		psys_render_restore(ob,psys);
+		Particle_Recalc(self,1);
+		Py_RETURN_NONE;
+	}
+
+	if (psys->part->type != PART_HAIR){
 		partlist = PyList_New( 0 );
 
+		if( !partlist ){
+			PyErr_SetString( PyExc_MemoryError, "PyList_New() failed" );
+			goto error;
+		}
+
 		if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
 			childexists = 1;
 
+		if(id)
+			fmt = "(ffffi)";
+		else
+			fmt = "(ffff)";
+
 		for (i = 0; i < psys->totpart + psys->totchild; i++){
 			if (childexists && (i < psys->totpart))
 				continue;
 
 			state.time = cfra;
 			if(psys_get_particle_state(ob,psys,i,&state,0)==0){
-				if ( all ){
-					PyList_Append(partlist,Py_None);
-					Py_DECREF(Py_None); /* PyList_Append increfs */
-					continue;
-				} else {
-					continue;
+				if ( all && PyList_Append(partlist,Py_None) < 0){
+					PyErr_SetString( PyExc_RuntimeError,
+						"Couldn't append item to PyList" );
+					goto error;
+				}
+			} else {
+				loc = Py_BuildValue(fmt,(double)state.rot[0], (double)state.rot[1],
+						(double)state.rot[2], (double)state.rot[3], i);
+
+				if (!loc){
+					PyErr_SetString( PyExc_RuntimeError,
+							"Couldn't build tuple" );
+					goto error;
+				}
+				if (PyList_Append(partlist,loc) < 0){
+					PyErr_SetString ( PyExc_RuntimeError,
+							"Couldn't append item to PyList" );
+					goto error;
 				}
+				Py_DECREF(loc); /* PyList_Append increfs */
+				loc = NULL;
 			}
-			if (!id)
-				loc = PyTuple_New(4);
-			else
-				loc = PyTuple_New(5);
-			PyTuple_SetItem(loc,0,PyFloat_FromDouble((double)state.rot[0]));
-			PyTuple_SetItem(loc,1,PyFloat_FromDouble((double)state.rot[1]));
-			PyTuple_SetItem(loc,2,PyFloat_FromDouble((double)state.rot[2]));
-			PyTuple_SetItem(loc,3,PyFloat_FromDouble((double)state.rot[3]));
-			if (id)
-				PyTuple_SetItem(loc,4,PyInt_FromLong(i));
-			PyList_Append(partlist,loc);
-			Py_DECREF(loc); /* PyList_Append increfs */
 		}
+	} else {
+		partlist = EXPP_incr_ret( Py_None );
 	}
+
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
 	return partlist;
+
+error:
+	Py_XDECREF(partlist);
+	Py_XDECREF(loc);
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
+	return NULL;
 }
 
-static PyObject *Part_GetSize( BPy_PartSys * self, PyObject * args ){
+static PyObject *Part_GetSize( BPy_PartSys * self, PyObject * args )
+{
 	ParticleKey state;
 	ParticleSystem *psys = 0L;
 	ParticleData *data;
 	Object *ob = 0L;
 	PyObject *partlist,*tuple;
-	PyObject* siz = 0L;
+	DerivedMesh* dm;
+	float vm[4][4],wm[4][4];
 	float size;
 	int i;
 	int childexists = 0;
 	int all = 0;
 	int id = 0;
+    char *fmt = NULL;
 
 	float cfra=bsystem_time(ob,(float)CFRA,0.0);
 
 	if( !PyArg_ParseTuple( args, "|ii", &all, &id ) )
 		return EXPP_ReturnPyObjError( PyExc_TypeError,
-				"expected one optional integer as argument" );
-
-	data = self->psys->particles;
+				"expected two optional integers as arguments" );
 
 	psys = self->psys;
 	ob = self->object;
@@ -1039,13 +1129,39 @@ static PyObject *Part_GetSize( BPy_PartSys * self, PyObject * args ){
 	if (!ob || !psys)
 		Py_RETURN_NONE;
 
-		partlist = PyList_New( 0 );
+	G.rendering = 1;
 
-		if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
-			childexists = 1;
+	/* Just to create a valid rendering context */
+	psys_render_set(ob,psys,vm,wm,0,0,0);
+
+	dm = mesh_create_derived_render(ob,CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
+	dm->release(dm);
+	data = self->psys->particles;
+
+	if ( !psys_check_enabled(ob,psys) ){
+		psys_render_restore(ob,psys);
+		G.rendering = 0;
+		Particle_Recalc(self,1);
+		Py_RETURN_NONE;
+	}
+
+	partlist = PyList_New( 0 );
+
+	if( !partlist ){
+		PyErr_SetString( PyExc_MemoryError, "PyList_New() failed" );
+		goto error;
+	}
+
+	if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
+		childexists = 1;
+
+	if(id)
+		fmt = "(fi)";
+	else
+		fmt = "f";
 
-		for (i = 0; i < psys->totpart + psys->totchild; i++, data++){
-		if (psys->part->type != 2){
+	for (i = 0; i < psys->totpart + psys->totchild; i++, data++){
+		if (psys->part->type != PART_HAIR){
 			if (childexists && (i < psys->totpart))
 				continue;
 
@@ -1061,43 +1177,61 @@ static PyObject *Part_GetSize( BPy_PartSys * self, PyObject * args ){
 				ChildParticle *cpa= &psys->child[i-psys->totpart];
 				size = psys_get_child_size(psys,cpa,cfra,0);
 			}
-			if (id){
-				tuple = PyTuple_New(2);
-				PyTuple_SetItem(tuple,0,PyFloat_FromDouble((double)size));
-				PyTuple_SetItem(tuple,1,PyInt_FromLong(i));
-				PyList_Append(partlist,tuple);
-				Py_DECREF(tuple);
-			} else {
-				siz = PyFloat_FromDouble((double)size);
-				PyList_Append(partlist,siz);
-				Py_DECREF(siz);
+
+			tuple = Py_BuildValue(fmt,(double)size,i);
+
+			if (!tuple){
+				PyErr_SetString( PyExc_RuntimeError,
+						"Couldn't build tuple" );
+				goto error;
+			}
+
+			if (PyList_Append(partlist,tuple) < 0){
+				PyErr_SetString( PyExc_RuntimeError,
+						"Couldn't append item to PyList" );
+				goto error;
 			}
+			Py_DECREF(tuple);
+			tuple = NULL;
 		}
 	}
+
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
 	return partlist;
+
+error:
+	Py_XDECREF(partlist);
+	Py_XDECREF(tuple);
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
+	return NULL;
 }
 
 
-static PyObject *Part_GetAge( BPy_PartSys * self, PyObject * args ){
+static PyObject *Part_GetAge( BPy_PartSys * self, PyObject * args )
+{
 	ParticleKey state;
 	ParticleSystem *psys = 0L;
 	ParticleData *data;
 	Object *ob = 0L;
 	PyObject *partlist,*tuple;
-	PyObject* lif = 0L;
+	DerivedMesh* dm;
+	float vm[4][4],wm[4][4];
 	float life;
 	int i;
 	int childexists = 0;
 	int all = 0;
 	int id = 0;
+	char *fmt = NULL;
 
 	float cfra=bsystem_time(ob,(float)CFRA,0.0);
 
 	if( !PyArg_ParseTuple( args, "|ii", &all, &id ) )
 		return EXPP_ReturnPyObjError( PyExc_TypeError,
-				"expected one optional integer as argument" );
-
-	data = self->psys->particles;
+				"expected two optional integers as arguments" );
 
 	psys = self->psys;
 	ob = self->object;
@@ -1105,13 +1239,37 @@ static PyObject *Part_GetAge( BPy_PartSys * self, PyObject * args ){
 	if (!ob || !psys)
 		Py_RETURN_NONE;
 
-		partlist = PyList_New( 0 );
+	G.rendering = 1;
 
-		if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
-			childexists = 1;
+	/* Just to create a valid rendering context */
+	psys_render_set(ob,psys,vm,wm,0,0,0);
+
+	dm = mesh_create_derived_render(ob,CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
+	dm->release(dm);
+	data = self->psys->particles;
+
+	if ( !psys_check_enabled(ob,psys) ){
+		psys_render_restore(ob,psys);
+		G.rendering = 0;
+		Py_RETURN_NONE;
+	}
+
+	partlist = PyList_New( 0 );
+	if( !partlist ){
+		PyErr_SetString( PyExc_MemoryError, "PyList_New() failed" );
+		goto error;
+	}
+
+	if (psys->totchild > 0 && !(psys->part->draw & PART_DRAW_PARENT))
+		childexists = 1;
+
+	if(id)
+		fmt = "(fi)";
+	else
+		fmt = "f";
 
-		for (i = 0; i < psys->totpart + psys->totchild; i++, data++){
-		if (psys->part->type != 2){
+	for (i = 0; i < psys->totpart + psys->totchild; i++, data++){
+		if (psys->part->type != PART_HAIR){
 
 			if (childexists && (i < psys->totpart))
 				continue;
@@ -1128,20 +1286,37 @@ static PyObject *Part_GetAge( BPy_PartSys * self, PyObject * args ){
 				ChildParticle *cpa= &psys->child[i-psys->totpart];
 				life = psys_get_child_time(psys,cpa,cfra);
 			}
-			if (id){
-				tuple = PyTuple_New(2);
-				PyTuple_SetItem(tuple,0,PyFloat_FromDouble((double)life));
-				PyTuple_SetItem(tuple,1,PyInt_FromLong(i));
-				PyList_Append(partlist,tuple);
-				Py_DECREF(tuple);
-			} else {
-				lif = PyFloat_FromDouble((double)life);
-				PyList_Append(partlist,lif);
-				Py_DECREF(lif);
+
+			tuple = Py_BuildValue(fmt,(double)life,i);
+
+			if (!tuple){
+				PyErr_SetString( PyExc_RuntimeError,
+						"Couldn't build tuple" );
+				goto error;
 			}
+
+			if (PyList_Append(partlist,tuple) < 0){
+				PyErr_SetString( PyExc_RuntimeError,
+						"Couldn't append item to PyList" );
+				goto error;
+			}
+			Py_DECREF(tuple);
+			tuple = NULL;
 		}
 	}
+
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
 	return partlist;
+
+error:
+	Py_XDECREF(partlist);
+	Py_XDECREF(tuple);
+	psys_render_restore(ob,psys);
+	G.rendering = 0;
+	Particle_Recalc(self,1);
+	return NULL;
 }
 
 
@@ -1376,11 +1551,8 @@ static int Part_set2d( BPy_PartSys * self, PyObject * args )
 {
 	int number;
 
-	if( !PyInt_Check( args ) ) {
-		char errstr[128];
-		sprintf ( errstr, "expected int argument" );
-		return EXPP_ReturnIntError( PyExc_TypeError, errstr );
-	}
+	if( !PyInt_Check( args ) )
+		return EXPP_ReturnIntError( PyExc_TypeError, "expected int argument" );
 
 	number = PyInt_AS_LONG( args );
 
@@ -1526,7 +1698,7 @@ static int Part_setRandEmission( BPy_PartSys * self, PyObject * args )
 
 static PyObject *Part_getRandEmission( BPy_PartSys * self )
 {
-	return PyInt_FromLong( ((long)( self->psys->part->flag & PART_BOIDS_2D )) > 0 );
+	return PyInt_FromLong( ((long)( self->psys->part->flag & PART_TRAND )) > 0 );
 }
 
 static int Part_setParticleDist( BPy_PartSys * self, PyObject * args )
@@ -1546,7 +1718,7 @@ static int Part_setParticleDist( BPy_PartSys * self, PyObject * args )
 		return EXPP_ReturnIntError( PyExc_TypeError, errstr );
 	}
 
-	self->psys->part->from = number;
+	self->psys->part->from = (short)number;
 
 	Particle_RecalcPsys_distr(self,1);
 
@@ -1603,7 +1775,7 @@ static int Part_setDist( BPy_PartSys * self, PyObject * args )
 		return EXPP_ReturnIntError( PyExc_TypeError, errstr );
 	}
 
-	self->psys->part->distr = number;
+	self->psys->part->distr = (short)number;
 
 	Particle_RecalcPsys_distr(self,1);
 
@@ -1731,7 +1903,7 @@ static int Part_setTargetPsys( BPy_PartSys * self, PyObject * args ){
 
 	res = EXPP_setIValueRange( args, &self->psys->target_psys, 0, tottpsys, 'h' );
 
-	if((psys=psys_get_current(ob))){
+	if( ( psys = psys_get_current(ob) ) ){
 		if(psys->keyed_ob==ob || psys->target_ob==ob){
 			if(psys->keyed_ob==ob)
 				psys->keyed_ob=NULL;
diff --git a/source/blender/python/api2_2x/doc/Ipo.py b/source/blender/python/api2_2x/doc/Ipo.py
index c479926ccf3..d1c72f8cb86 100644
--- a/source/blender/python/api2_2x/doc/Ipo.py
+++ b/source/blender/python/api2_2x/doc/Ipo.py
@@ -250,7 +250,7 @@ class Ipo:
 			OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
 			Disp.
 			3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
-			dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
+			dRotX, dRotY, dRotZ, ScaleX, ScaleY, ScaleZ, dScaleX, dScaleY, dScaleZ,
 			Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
 			RDamp, Perm.
 			4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
@@ -289,7 +289,7 @@ class Ipo:
 			OfsZ, SizeX, SizeY, SizeZ, texR, texG, texB, DefVar, Col, Nor, Var,
 			Disp.
 			3. Object Ipo: LocX, LocY, LocZ, dLocX, dLocY, dLocZ, RotX, RotY, RotZ,
-			dRotX, dRotY, dRotZ, SizeX, SizeY, SizeZ, dSizeX, dSizeY, dSizeZ,
+			dRotX, dRotY, dRotZ, ScaleX, ScaleY, ScaleZ, dScaleX, dScaleY, dScaleZ,
 			Layer, Time, ColR, ColG, ColB, ColA, FStreng, FFall, Damping,
 			RDamp, Perm.
 			4. Lamp Ipo: Energ, R, G, B, Dist, SpoSi, SpoBl, Quad1, Quad2, HaInt.
diff --git a/source/blender/python/api2_2x/doc/LibData.py b/source/blender/python/api2_2x/doc/LibData.py
index 47bd7fdb763..daa6a186531 100644
--- a/source/blender/python/api2_2x/doc/LibData.py
+++ b/source/blender/python/api2_2x/doc/LibData.py
@@ -27,17 +27,37 @@ Example::
 """
 
 def load(filename,relative=False):
-  """
-  Select an existing .blend file for use as a library.  Unlike the 
-  Library module, multiple libraries can be defined at the same time.  
-  
-  @type filename: string
-  @param filename: The filename of a Blender file. Filenames starting with "//" will be loaded relative to the blend file's location.
-  @type relative: boolean
-  @param relative: Convert relative paths to absolute paths (default).  Setting this parameter to True will leave paths relative.
-  @rtype: Library
-  @return: return a L{Library} object.
-  """
+	"""
+	Select an existing .blend file for use as a library.  Unlike the 
+	Library module, multiple libraries can be defined at the same time.  
+	
+	@type filename: string
+	@param filename: The filename of a Blender file. Filenames starting with "//" will be loaded relative to the blend file's location.
+	@type relative: boolean
+	@param relative: Convert relative paths to absolute paths (default).  Setting this parameter to True will leave paths relative.
+	@rtype: Library
+	@return: return a L{Library} object.
+	"""
+
+def paths(link=0):
+	"""
+	Returns a list of paths used in the current blend file.
+	
+	@type link: int
+	@param link: 0 (default if no args given) for all library paths, 1 for directly linked library paths only, 2 for indirectly linked library paths only.
+	@rtype: List
+	@return: return a list of path strings.
+	"""
+
+def replace(pathFrom, pathTo):
+	"""
+	Replaces an existing directly linked path.
+	
+	@type pathFrom: string
+	@param pathFrom: An existing library path.
+	@type pathTo: string
+	@param pathTo: A new library path.
+	"""
 
 class Libraries:
 	"""
diff --git a/source/blender/python/api2_2x/doc/Particle.py b/source/blender/python/api2_2x/doc/Particle.py
index 192ecd5355b..511ad81b45f 100644
--- a/source/blender/python/api2_2x/doc/Particle.py
+++ b/source/blender/python/api2_2x/doc/Particle.py
@@ -56,17 +56,17 @@ class Particle:
 	@type type: int
 	@ivar resolutionGrid: The resolution of the particle grid.
 	@type resolutionGrid: int
-	@ivar startFrame: Frame # to start emitting particles.
+	@ivar startFrame: Frame number to start emitting particles.
 	@type startFrame: float
-	@ivar endFrame: Frame # to stop emitting particles.
+	@ivar endFrame: Frame number to stop emitting particles.
 	@type endFrame: float
 	@ivar editable: Finalize hair to enable editing in particle mode.
 	@type editable: int
 	@ivar amount: The total number of particles.
 	@type amount: int
-	@ivar multireact: React multiple times ( Paricle.REACTON[ 'NEAR' | 'COLLISION' | 'DEATH' ] ).
+	@ivar multireact: React multiple times ( Particle.REACTON[ 'NEAR' | 'COLLISION' | 'DEATH' ] ).
 	@type multireact: int
-	@ivar reactshape: Power of reaction strength dependence on distance to target.
+	@ivar reactshape: Power of reaction strength, dependent on distance to target.
 	@type reactshape: float
 	@ivar hairSegments: Amount of hair segments.
 	@type hairSegments: int
@@ -74,13 +74,13 @@ class Particle:
 	@type lifetime: float
 	@ivar randlife: Give the particle life a random variation.
 	@type randlife: float
-	@ivar randemission: Give the particle life a random variation
+	@ivar randemission: Emit particles in random order.
 	@type randemission: int
-	@ivar particleDistribution: Where to emit particles from  Paricle.EMITFROM[ 'PARTICLE' | 'VOLUME' | 'FACES' | 'VERTS' ] )
+	@ivar particleDistribution: Where to emit particles from  ( Particle.EMITFROM[ 'PARTICLE' | 'VOLUME' | 'FACES' | 'VERTS' ] )
 	@type particleDistribution: int
 	@ivar evenDistribution: Use even distribution from faces based on face areas or edge lengths.
 	@type evenDistribution: int
-	@ivar distribution: How to distribute particles on selected element Paricle.DISTRIBUTION[ 'GRID' | 'RANDOM' | 'JITTERED' ] ).
+	@ivar distribution: How to distribute particles on selected element ( Particle.DISTRIBUTION[ 'GRID' | 'RANDOM' | 'JITTERED' ] ).
 	@type distribution: int
 	@ivar jitterAmount: Amount of jitter applied to the sampling.
 	@type jitterAmount: float
@@ -131,237 +131,56 @@ class Particle:
 		Get the particles locations.
 		A list of tuple is returned in particle mode.
 		A list of list of tuple is returned in hair mode.
-		The tuple is a vector list of 3 or 4 floats in world space (x,y,z, optionnaly the particle's id).
+		The tuple is a vector of 3 or 4 floats in world space (x,y,z,
+optionally the particle's id).
 		@type all: int
 		@param all: if not 0 export all particles (uninitialized (unborn or died)particles exported as None).
 		@type id: int
 		@param id: add the particle id in the end of the vector tuple
-		@rtype: list of vectors (tuple of 3 floats and optionnaly the id) or list of list of vectors
-		@return: list of vectors or list of list of vectors (hair mode)
+		@rtype: list of vectors (tuple of 3 floats and optionally the id) or list of list of vectors
+		@return: list of vectors or list of list of vectors (hair mode) or None if system is disabled
 		"""
 	def getRot(all=0,id=0):
 		"""
-		Get the particles rotations as quaternion.
+		Get the particles' rotations as quaternion.
 		A list of tuple is returned in particle mode.
-		The tuple is a vector list of 4 or 5 floats (x,y,z,w, optionnaly the id of the particle).
+		The tuple is vector of 4 or 5 floats (x,y,z,w, optionally the id of the particle).
 		
 		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died) particles exported as None).
+		@param all: if not 0, export all particles (uninitialized (unborn or died) particles exported as None).
 		@type id: int
 		@param id: add the particle id in the return tuple
 		@rtype: list of tuple of 4 or 5 elements (if id is not zero)
-		@return: list of 4-tuples
+		@return: list of 4-tuples or None if system is disabled
 		"""
 		
 	def getMat():
 		"""
-		Get the particles material.
+		Get the particles' material.
 		@rtype: Blender Material
-		@return: The marterial assigned to particles
+		@return: The material assigned to particles
 		"""
 		
 	def getSize(all=0,id=0):
 		"""
-		Get the particles size.
+		Get the particles' size.
 		A list of float or list of tuple (particle's size,particle's id).
 		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died) particles exported as None).
+		@param all: if not 0, export all particles (uninitialized (unborn or died) particles exported as None).
 		@type id: int
 		@param id: add the particle id in the return tuple
 		@rtype: list of floats
-		@return: list of floats or list of tuples if id is not zero (size,id).
+		@return: list of floats or list of tuples if id is not zero (size,id) or None if system is disabled.
 		"""
 		
 	def getAge(all=0,id=0):
 		"""
-		Get the particles age.
-		A list of float or list of tuple (particle's age,particle's id).
+		Get the particles' age.
+		A list of float or list of tuple (particle's age, particle's id).
 		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died) particles exported as None).
+		@param all: if not 0, export all particles (uninitialized (unborn or died) particles exported as None).
 		@type id: int
 		@param id: add the particle id in the return tuple
 		@rtype: list of floats
-		@return: list of floats or list of tuples if id is not zero (size,id).
-		"""
-# Blender.Object module and the Object PyType object
-
-"""
-The Blender.Particle submodule
-
-
-Particle
-========
-
-This module provides access to the B{Particle} in Blender.
-
-@type TYPE: readonly dictionary
-@var TYPE: Constant dict used for with L{Particle.TYPE}
-		- HAIR: set particle system to hair mode.
-		- REACTOR: set particle system to reactor mode.
-		- EMITTER: set particle system to emitter mode.
-@type DISTRIBUTION: readonly dictionary
-@var DISTRIBUTION: Constant dict used for with L{Particle.DISTRIBUTION}
-		- GRID: set grid distribution.
-		- RANDOM: set random distribution.
-		- JITTERED: set jittered distribution.
-@type EMITFROM: readonly dictionary
-@var EMITFROM: Constant dict used for with L{Particle.EMITFROM}
-		- VERTS: set particles emit from vertices
-		- FACES: set particles emit from faces
-		- VOLUME: set particles emit from volume
-		- PARTICLE: set particles emit from particles
-@type REACTON: readonly dictionary
-@var REACTON: Constant dict used for with L{Particle.REACTON}
-		- NEAR: react on near
-		- COLLISION: react on collision
-		- DEATH: react on death
-@type DRAWAS: readonly dictionary
-@var DRAWAS: Constant dict used for with L{Particle.DRAWAS}
-		- NONE: Don't draw
-		- POINT: Draw as point
-		- CIRCLE: Draw as circles
-		- CROSS: Draw as crosses
-		- AXIS: Draw as axis
-		- LINE: Draw as lines
-		- PATH: Draw pathes
-		- OBJECT: Draw object
-		- GROUP: Draw goup
-		- BILLBOARD: Draw as billboard 
-"""
-
-def Get(name):
-		"""
-		Get the particle system of the object "name".
-		@type name: string
-		@return: The particle system of the object.
-		"""
-def New(name):
-		"""
-		Assign a new particle system to the object "name".
-		@type name: string
-		@return: The newly created particle system.
-		"""
-
-class Particle:
-	"""
-	The Particle object
-	===================
-		This object gives access to paticles data.
-		
-	@ivar seed: Set an offset in the random table.
-	@type seed: int
-	@ivar type: Type of particle system ( Particle.TYPE[ 'HAIR' | 'REACTOR' | 'EMITTER' ] ).
-	@type type: int
-	@ivar resolutionGrid: The resolution of the particle grid.
-	@type resolutionGrid: int
-	@ivar startFrame: Frame # to start emitting particles.
-	@type startFrame: float
-	@ivar endFrame: Frame # to stop emitting particles.
-	@type endFrame: float
-	@ivar editable: Finalize hair to enable editing in particle mode.
-	@type editable: int
-	@ivar amount: The total number of particles.
-	@type amount: int
-	@ivar multireact: React multiple times ( Paricle.REACTON[ 'NEAR' | 'COLLISION' | 'DEATH' ] ).
-	@type multireact: int
-	@ivar reactshape: Power of reaction strength dependence on distance to target.
-	@type reactshape: float
-	@ivar hairSegments: Amount of hair segments.
-	@type hairSegments: int
-	@ivar lifetime: Specify the life span of the particles.
-	@type lifetime: float
-	@ivar randlife: Give the particle life a random variation.
-	@type randlife: float
-	@ivar randemission: Give the particle life a random variation
-	@type randemission: int
-	@ivar particleDistribution: Where to emit particles from  Paricle.EMITFROM[ 'PARTICLE' | 'VOLUME' | 'FACES' | 'VERTS' ] )
-	@type particleDistribution: int
-	@ivar evenDistribution: Use even distribution from faces based on face areas or edge lengths.
-	@type evenDistribution: int
-	@ivar distribution: How to distribute particles on selected element Paricle.DISTRIBUTION[ 'GRID' | 'RANDOM' | 'JITTERED' ] ).
-	@type distribution: int
-	@ivar jitterAmount: Amount of jitter applied to the sampling.
-	@type jitterAmount: float
-	@ivar pf: Emission locations / face (0 = automatic).
-	@type pf:int
-	@ivar invert: Invert what is considered object and what is not.
-	@type invert: int
-	@ivar targetObject: The object that has the target particle system (empty if same object).
-	@type targetObject: Blender object
-	@ivar targetpsys: The target particle system number in the object.
-	@type targetpsys: int
-	@ivar 2d: Constrain boids to a surface.
-	@type 2d: float
-	@ivar maxvel: Maximum velocity.
-	@type maxvel: float
-	@ivar avvel: The usual speed % of max velocity.
-	@type avvel: float
-	@ivar latacc: Lateral acceleration % of max velocity
-	@type latacc: float
-	@ivar tanacc: Tangential acceleration % of max velocity
-	@type tanacc: float
-	@ivar groundz: Default Z value.
-	@type groundz: float
-	@ivar object: Constrain boids to object's surface.
-	@type object: Blender Object
-	@ivar renderEmitter: Render emitter object.
-	@type renderEmitter: int
-	@ivar displayPercentage: Particle display percentage.
-	@type displayPercentage: int
-	@ivar hairDisplayStep: How many steps paths are drawn with (power of 2) in visu mode.
-	@type hairDisplayStep: int
-	@ivar hairRenderStep: How many steps paths are rendered with (power of 2) in render mode."
-	@type hairRenderStep: int
-	@ivar duplicateObject: Get the duplicate object.
-	@type duplicateObject: Blender Object
-	@ivar drawAs: Get draw type Particle.DRAWAS([ 'NONE' | 'OBJECT' | 'POINT' | ... ]).
-	@type drawAs: int
-	"""
-	def freeEdit():
-		"""
-		Free edit mode.
-		@return: None
-		"""
-
-	def getLoc(all=0,id=0):
-		"""
-		Get the particles locations.
-		A list of tuple is returned in particle mode.
-		A list of list of tuple is returned in hair mode.
-		The tuple is a vector list of 3 floats in world space.
-		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died)particles exported as None).
-		@type id: int
-		@param id: add the particle id in the end of the vector tuple
-		@rtype: list of vectors (tuple of 3 floats and optionnaly the id) or list of list of vectors
-		@return: list of vectors or list of list of vectors (hair mode)
-		"""
-	def getRot(all=0,id=0):
-		"""
-		Get the particles rotations as quaternion.
-		A list of tuple is returned in particle mode.
-		The tuple is a vector list of 4 floats (quaternion).
-		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died) particles exported as None).
-		@type id: int
-		@param id: add the particle id in the return tuple
-		@rtype: list of tuple of 4 or 5 elements (if id is not zero)
-		@return: list of 4-tuples
-		"""
-	def getMat():
-		"""
-		Get the particles material.
-		@rtype: Blender Material
-		@return: The marterial assigned to particles
-		"""
-	def getSize(all=0,id=0):
-		"""
-		Get the particles size.
-		A list of float.
-		@type all: int
-		@param all: if not 0 export all particles (uninitialized (unborn or died) particles exported as None).
-		@type id: int
-		@param id: add the particle id in the return tuple
-		@rtype: list of floats
-		@return: list of floats or list of tuples if id is not zero (size,id).
+		@return: list of floats or list of tuples if id is not zero (size,id) or None if system is disabled.
 		"""
diff --git a/source/blender/python/api2_2x/doc/Render.py b/source/blender/python/api2_2x/doc/Render.py
index 475a4fc5b10..d4dc83e84a0 100644
--- a/source/blender/python/api2_2x/doc/Render.py
+++ b/source/blender/python/api2_2x/doc/Render.py
@@ -833,9 +833,7 @@ class RenderData:
 
   def enableCropping(toggle):
     """
-    Enable/disable exclusion of border rendering from total image.
-    @type toggle: int
-    @param toggle: pass 1 for on / 0 for off
+    Deprecated: see the L{crop} attribute.
     """
 
   def setImageType(type):
diff --git a/source/blender/python/api2_2x/sceneRender.c b/source/blender/python/api2_2x/sceneRender.c
index b446af7efd4..6fc3a2b18d1 100644
--- a/source/blender/python/api2_2x/sceneRender.c
+++ b/source/blender/python/api2_2x/sceneRender.c
@@ -972,6 +972,8 @@ static int RenderData_setRenderer( BPy_RenderData * self, PyObject * value )
 		self->renderContext->renderer = R_INTERN;
 	else if( type == R_YAFRAY )
 		self->renderContext->renderer = R_YAFRAY;
+	else if( type == R_FREESTYLE )
+		self->renderContext->renderer = R_FREESTYLE;
 	else
 		return EXPP_ReturnIntError( PyExc_ValueError,
 				"expected constant INTERNAL or YAFRAY" );
@@ -985,7 +987,7 @@ PyObject *RenderData_EnableCropping( void )
 /*	return M_Render_BitToggleInt( args, R_MOVIECROP,
 				      &self->renderContext->mode );
 */
-	printf("cropping option is now default, obsolete\n");
+	printf("obsolete: movie cropping option is now default\n");
 	Py_RETURN_NONE;
 }
 
@@ -3485,6 +3487,10 @@ static PyGetSetDef BPy_RenderLayer_getseters[] = {
 	 (getter)RenderLayer_getLayflagBits, (setter)RenderLayer_setLayflagBits,
 	 "Render Edge-enhance in this Layer (only works for Solid faces)",
 	 (void *)SCE_LAY_EDGE},
+	{"enableFreestyle",
+	 (getter)RenderLayer_getLayflagBits, (setter)RenderLayer_setLayflagBits,
+	 "Render Freestyle in this Layer",
+	 (void *)SCE_LAY_FRS},
 	{"enableSky",
 	 (getter)RenderLayer_getLayflagBits, (setter)RenderLayer_setLayflagBits,
 	 "Render Sky or backbuffer in this Layer",
@@ -3838,6 +3844,7 @@ PyObject *Render_Init( void )
 
 	PyModule_AddIntConstant( submodule, "INTERNAL", R_INTERN );
 	PyModule_AddIntConstant( submodule, "YAFRAY", R_YAFRAY );
+	PyModule_AddIntConstant( submodule, "FREESTYLE", R_FREESTYLE );
 	PyModule_AddIntConstant( submodule, "AVIRAW", R_AVIRAW );
 	PyModule_AddIntConstant( submodule, "AVIJPEG", R_AVIJPEG );
 	PyModule_AddIntConstant( submodule, "AVICODEC", R_AVICODEC );
diff --git a/source/blender/render/SConscript b/source/blender/render/SConscript
index b1bc9673f23..52f5042cd50 100644
--- a/source/blender/render/SConscript
+++ b/source/blender/render/SConscript
@@ -7,6 +7,7 @@ sources = env.Glob('intern/source/*.c')
 incs = 'intern/include #/intern/guardedalloc ../blenlib ../makesdna'
 incs += ' extern/include ../blenkernel ../radiosity/extern/include ../imbuf'
 incs += ' ../quicktime ../include ../../kernel/gen_messaging'
+incs += ' ../freestyle'
 
 defs = []
 
@@ -28,4 +29,4 @@ if env['WITH_BF_OPENEXR']:
 if env['OURPLATFORM']=='linux2':
     cflags='-pthread'
 
-env.BlenderLib ( libname = 'blender_render', sources = sources, includes = Split(incs), defines=defs, libtype='core', priority=45, compileflags=cflags )
+env.BlenderLib ( libname = 'blender_render', sources = sources, includes = Split(incs), defines=defs, libtype=['core'], priority=[45], compileflags=cflags )
diff --git a/source/blender/render/intern/source/pipeline.c b/source/blender/render/intern/source/pipeline.c
index 6a0af82b4d7..888eca414d0 100644
--- a/source/blender/render/intern/source/pipeline.c
+++ b/source/blender/render/intern/source/pipeline.c
@@ -70,6 +70,9 @@
 
 #endif /* disable yafray */
 
+#include "FRS_freestyle.h"
+
+
 /* internal */
 #include "render_types.h"
 #include "renderpipeline.h"
@@ -1618,7 +1621,7 @@ void RE_TileProcessor(Render *re, int firsttile, int threaded)
 
 static void do_render_3d(Render *re)
 {
-	
+
 //	re->cfra= cfra;	/* <- unused! */
 	
 	/* make render verts/faces/halos/lamps */
@@ -1629,6 +1632,12 @@ static void do_render_3d(Render *re)
 	
 	threaded_tile_processor(re);
 	
+	/* Freestyle */
+	if( re->r.mode & R_EDGE_FRS ) {
+		FRS_prepare(re);
+		FRS_execute(re,1);
+	}
+	
 	/* do left-over 3d post effects (flares) */
 	if(re->flag & R_HALO)
 		if(!re->test_break())
@@ -2189,6 +2198,34 @@ static void do_render_composite_fields_blur_3d(Render *re)
 	re->display_draw(re->result, NULL);
 }
 
+static void freestyleRender(Render *re)
+{
+	float mat[4][4];
+	
+	// init render result
+	RE_FreeRenderResult(re->result);
+	re->result = new_render_result(re, &re->disprect, 0, RR_USEMEM);
+	
+	// set camera
+	RE_SetCamera(re, re->scene->camera);
+	
+	// set view
+	Mat4Ortho(re->scene->camera->obmat);
+	Mat4Invert(mat, re->scene->camera->obmat);
+	RE_SetView(re, mat);
+	
+	// Freestyle initialization
+	FRS_prepare(re);
+	
+	// run Freestyle
+	re->i.starttime = PIL_check_seconds_timer();
+	FRS_execute(re, 0);
+	re->i.lastframetime = PIL_check_seconds_timer()- re->i.starttime;
+	re->stats_draw(&re->i);
+	
+	RE_Database_Free(re);
+}
+
 #ifndef DISABLE_YAFRAY
 /* yafray: main yafray render/export call */
 static void yafrayRender(Render *re)
@@ -2283,10 +2320,15 @@ static void do_render_all_options(Render *re)
 #ifndef DISABLE_YAFRAY
 		if(re->r.renderer==R_YAFRAY)
 			yafrayRender(re);
+		else if(re->r.renderer==R_FREESTYLE)
+			freestyleRender(re);
 		else
 			do_render_composite_fields_blur_3d(re);
 #else
-		do_render_composite_fields_blur_3d(re);
+		if(re->r.renderer==R_FREESTYLE)
+			freestyleRender(re);
+		else
+			do_render_composite_fields_blur_3d(re);
 #endif
 	}
 	
@@ -2399,7 +2441,7 @@ static int is_rendering_allowed(Render *re)
 	}
 	
 	/* renderer */
-	if(!ELEM(re->r.renderer, R_INTERN, R_YAFRAY)) {
+	if(!ELEM3(re->r.renderer, R_INTERN, R_YAFRAY, R_FREESTYLE)) {
 		re->error("Unknown render engine set");
 		return 0;
 	}
diff --git a/source/blender/render/intern/source/rendercore.c b/source/blender/render/intern/source/rendercore.c
index 67be0ce4c00..4520e4c10bb 100644
--- a/source/blender/render/intern/source/rendercore.c
+++ b/source/blender/render/intern/source/rendercore.c
@@ -671,8 +671,10 @@ static void atm_tile(RenderPart *pa, RenderLayer *rl)
 	RenderPass *zpass;
 	GroupObject *go;
 	LampRen *lar;
-	
-	int x, y;
+	RenderLayer *rlpp[RE_MAX_OSA];
+
+	int totsample, fullsample, sample;
+	int x, y,od;
 	short first_lamp;
 	float *zrect;
 	float *rgbrect;
@@ -683,7 +685,10 @@ static void atm_tile(RenderPart *pa, RenderLayer *rl)
 	
 	fac = 0.5;
 	facm = 1.0 - fac;
-	
+
+	totsample= get_sample_layers(pa, rl, rlpp);
+	fullsample= (totsample > 1);
+
 	/* check that z pass is enabled */
 	if(pa->rectz==NULL) return;
 	for(zpass= rl->passes.first; zpass; zpass= zpass->next)
@@ -708,9 +713,10 @@ static void atm_tile(RenderPart *pa, RenderLayer *rl)
 	
 	zrect = zpass->rect;
 	rgbrect = rl->rectf;
+	od=0;
 	/* for each x,y and sun lamp*/
 	for(y=pa->disprect.ymin; y<pa->disprect.ymax; y++) {
-		for(x=pa->disprect.xmin; x<pa->disprect.xmax; x++, zrect++, rgbrect+=4) {
+		for(x=pa->disprect.xmin; x<pa->disprect.xmax; x++, zrect++, od++) {
 			
 			first_lamp = 1;
 			for(go=R.lights.first; go; go= go->next) {
@@ -724,7 +730,7 @@ static void atm_tile(RenderPart *pa, RenderLayer *rl)
 					}
 
 					if(lar->sunsky->effect_type & LA_SUN_EFFECT_AP){	
-						VECCOPY(tmp_rgb, rgbrect);
+						VECCOPY(tmp_rgb, (float*)(rgbrect+4*od));
 
 						shadeAtmPixel(lar->sunsky, tmp_rgb, x, y, *zrect);
 						
@@ -743,7 +749,16 @@ static void atm_tile(RenderPart *pa, RenderLayer *rl)
 
 			/* if at least for one sun lamp aerial perspective was applied*/
 			if(first_lamp==0)
-				VECCOPY(rgbrect, rgb);
+			{
+				if(fullsample) {
+					for(sample=0; sample<totsample; sample++) {
+						VECCOPY((float*)(rlpp[sample]->rectf + od*4), rgb);
+					}
+				}
+				else {
+					VECCOPY((float*)(rgbrect+4*od), rgb);
+				}
+			}
 		}
 	}
 }
diff --git a/source/blender/render/intern/source/shadeoutput.c b/source/blender/render/intern/source/shadeoutput.c
index 0928042729a..5b69323667e 100644
--- a/source/blender/render/intern/source/shadeoutput.c
+++ b/source/blender/render/intern/source/shadeoutput.c
@@ -1379,6 +1379,8 @@ static void shade_one_light(LampRen *lar, ShadeInput *shi, ShadeResult *shr, int
 		}
 		
 		/* specularity */
+		shadfac[3]*= phongcorr;	/* note, shadfac not allowed to be stored nonlocal */
+		
 		if(shadfac[3]>0.0f && shi->spec!=0.0f && !(lar->mode & LA_NO_SPEC) && !(lar->mode & LA_ONLYSHADOW)) {
 			
 			if(!(passflag & (SCE_PASS_COMBINED|SCE_PASS_SPEC)));
diff --git a/source/blender/render/intern/source/zbuf.c b/source/blender/render/intern/source/zbuf.c
index 579905315bb..c91c9e2f799 100644
--- a/source/blender/render/intern/source/zbuf.c
+++ b/source/blender/render/intern/source/zbuf.c
@@ -3545,7 +3545,7 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
 	
 	for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
 		float *col= NULL;
-		int pixsize= 0;
+		int pixsize= 3;
 		
 		switch(rpass->passtype) {
 			case SCE_PASS_RGBA:
@@ -3580,6 +3580,10 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
 				col= &shr->mist;
 				pixsize= 1;
 				break;
+			case SCE_PASS_Z:
+				col= &shr->z;
+				pixsize= 1;
+				break;
 			case SCE_PASS_VECTOR:
 				
 				{
@@ -3612,14 +3616,18 @@ void merge_transp_passes(RenderLayer *rl, ShadeResult *shr)
 			
 			for(samp= 1; samp<R.osa; samp++, fp+=delta) {
 				col[0]+= fp[0];
-				col[1]+= fp[1];
-				col[2]+= fp[2];
-				if(pixsize) col[3]+= fp[3];
+				if(pixsize>1) {
+					col[1]+= fp[1];
+					col[2]+= fp[2];
+					if(pixsize==4) col[3]+= fp[3];
+				}
 			}
 			col[0]*= weight;
-			col[1]*= weight;
-			col[2]*= weight;
-			if(pixsize) col[3]*= weight;
+			if(pixsize>1) {
+				col[1]*= weight;
+				col[2]*= weight;
+				if(pixsize==4) col[3]*= weight;
+			}
 		}
 	}
 				
@@ -3973,7 +3981,7 @@ unsigned short *zbuffer_transp_shade(RenderPart *pa, RenderLayer *rl, float *pas
 
 	/* general shader info, passes */
 	shade_sample_initialize(&ssamp, pa, rl);
-	addpassflag= rl->passflag & ~(SCE_PASS_Z|SCE_PASS_COMBINED);
+	addpassflag= rl->passflag & ~(SCE_PASS_COMBINED);
 	addzbuf= rl->passflag & SCE_PASS_Z;
 	
 	if(R.osa)
diff --git a/source/blender/src/buttons_editing.c b/source/blender/src/buttons_editing.c
index 7eff79fec88..529a795a101 100644
--- a/source/blender/src/buttons_editing.c
+++ b/source/blender/src/buttons_editing.c
@@ -513,7 +513,6 @@ void do_common_editbuts(unsigned short event) // old name, is a mix of object an
 				} else {
 					editmesh_deselect_by_material(G.obedit->actcol-1);
 				}
-				allqueue(REDRAWVIEW3D, 0);
 			}
 			else if ELEM(G.obedit->type, OB_CURVE, OB_SURF) {
 				nu= editNurb.first;
@@ -553,8 +552,9 @@ void do_common_editbuts(unsigned short event) // old name, is a mix of object an
 					nu= nu->next;
 				}
 				BIF_undo_push("Select material index");
-				allqueue(REDRAWVIEW3D, 0);
 			}
+			allqueue(REDRAWIMAGE, 0);
+			allqueue(REDRAWVIEW3D, 0);
 		}
 		countall();
 		break;
@@ -5153,32 +5153,6 @@ static void verify_posegroup_groupname(void *arg1, void *arg2)
 	BLI_uniquename(&pose->agroups, grp, "Group", offsetof(bActionGroup, name), 32);
 }
 
-static char *build_colorsets_menustr ()
-{
-	DynStr *pupds= BLI_dynstr_new();
-	char *str;
-	char buf[48];
-	int i;
-	
-	/* add title first (and the "default" entry) */
-	BLI_dynstr_append(pupds, "Bone Color Set%t|Default Colors%x0|");
-	
-	/* loop through set indices, adding them */
-	for (i=1; i<21; i++) {
-		sprintf(buf, "%d - Theme Color Set%%x%d|", i, i);
-		BLI_dynstr_append(pupds, buf);
-	}
-	
-	/* add the 'custom' entry */
-	BLI_dynstr_append(pupds, "Custom Set %x-1");
-	
-	/* convert to normal MEM_malloc'd string */
-	str= BLI_dynstr_get_cstring(pupds);
-	BLI_dynstr_free(pupds);
-	
-	return str;
-}
-
 static void editing_panel_links(Object *ob)
 {
 	uiBlock *block;
@@ -5338,32 +5312,14 @@ static void editing_panel_links(Object *ob)
 			/* color set for 'active' group */
 			if (pose->active_group && grp) {
 				uiBlockBeginAlign(block);
-					menustr= build_colorsets_menustr();
+					menustr= BIF_ThemeColorSetsPup(1);
 					uiDefButI(block, MENU,B_POSEGRP_RECALC, menustr, xco,85,140,19, &grp->customCol, -1, 20, 0.0, 0.0, "Index of set of Custom Colors to shade Group's bones with. 0 = Use Default Color Scheme, -1 = Use Custom Color Scheme");						
 					MEM_freeN(menustr);
 					
 					/* show color-selection/preview */
 					if (grp->customCol) {
-						if (grp->customCol > 0) {
-							/* copy theme colors on-to group's custom color in case user tries to edit color */
-							bTheme *btheme= U.themes.first;
-							ThemeWireColor *col_set= &btheme->tarm[(grp->customCol - 1)];
-							
-							memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
-						}
-						else {
-							/* init custom colors with a generic multi-color rgb set, if not initialised already */
-							if (grp->cs.solid[0] == 0) {
-								/* define for setting colors in theme below */
-								#define SETCOL(col, r, g, b, a)  col[0]=r; col[1]=g; col[2]= b; col[3]= a;
-								
-								SETCOL(grp->cs.solid, 0xff, 0x00, 0x00, 255);
-								SETCOL(grp->cs.select, 0x81, 0xe6, 0x14, 255);
-								SETCOL(grp->cs.active, 0x18, 0xb6, 0xe0, 255);
-								
-								#undef SETCOL
-							}
-						}
+						/* do color copying/init (to stay up to date) */
+						actionbone_group_copycolors(grp, 1);
 						
 						/* color changing */
 						uiDefButC(block, COL, B_POSEGRP_MCUSTOM, "",		xco, 65, 30, 19, grp->cs.solid, 0, 0, 0, 0, "Color to use for surface of bones");
diff --git a/source/blender/src/buttons_logic.c b/source/blender/src/buttons_logic.c
index cc4df06e22d..6b29a05bd22 100644
--- a/source/blender/src/buttons_logic.c
+++ b/source/blender/src/buttons_logic.c
@@ -2062,7 +2062,7 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
 			coa->time = 0;
 			uiDefButS(block, MENU, 1, str,		xco+10, yco-65, 70, 19, &coa->flag, 0.0, 0.0, 0, 0, "");
 		
-			uiDefButS(block, NUM,		0, "Damp:",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "");
+			uiDefButS(block, NUM,		0, "damp",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "Damping factor: time constant (in frame) of low pass filter");
 			uiDefBut(block, LABEL,			0, "Min",	xco+80, yco-45, (width-90)/2, 19, NULL, 0.0, 0.0, 0, 0, "");
 			uiDefBut(block, LABEL,			0, "Max",	xco+80+(width-90)/2, yco-45, (width-90)/2, 19, NULL, 0.0, 0.0, 0, 0, "");
 
@@ -2084,7 +2084,7 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
 			str= "Direction %t|None %x0|X axis %x1|Y axis %x2|Z axis %x4|-X axis %x8|-Y axis %x16|-Z axis %x32";
 			uiDefButS(block, MENU, B_REDR, str,		xco+10, yco-65, 70, 19, &coa->mode, 0.0, 0.0, 0, 0, "Set the direction of the ray");
 		
-			uiDefButS(block, NUM,		0, "Damp:",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "");
+			uiDefButS(block, NUM,		0, "damp",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "Damping factor: time constant (in frame) of low pass filter");
 			uiDefBut(block, LABEL,			0, "Range",	xco+80, yco-45, (width-115)/2, 19, NULL, 0.0, 0.0, 0, 0, "Set the maximum length of ray");
 			uiDefButBitS(block, TOG, ACT_CONST_DISTANCE, B_REDR, "Dist",	xco+80+(width-115)/2, yco-45, (width-115)/2, 19, &coa->flag, 0.0, 0.0, 0, 0, "Force distance of object to point of impact of ray");
 
@@ -2124,7 +2124,7 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
 			str= "Direction %t|None %x0|X axis %x1|Y axis %x2|Z axis %x4";
 			uiDefButS(block, MENU, B_REDR, str,		xco+10, yco-65, 70, 19, &coa->mode, 0.0, 0.0, 0, 0, "Select the axis to be aligned along the reference direction");
 		
-			uiDefButS(block, NUM,		0, "Damp:",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "");
+			uiDefButS(block, NUM,		0, "damp",	xco+10, yco-45, 70, 19, &coa->damp, 0.0, 100.0, 0, 0, "Damping factor: time constant (in frame) of low pass filter");
 			uiDefBut(block, LABEL,			0, "X",	xco+80, yco-45, (width-115)/3, 19, NULL, 0.0, 0.0, 0, 0, "");
 			uiDefBut(block, LABEL,			0, "Y",	xco+80+(width-115)/3, yco-45, (width-115)/3, 19, NULL, 0.0, 0.0, 0, 0, "");
 			uiDefBut(block, LABEL,			0, "Z",	xco+80+2*(width-115)/3, yco-45, (width-115)/3, 19, NULL, 0.0, 0.0, 0, 0, "");
@@ -2133,7 +2133,9 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
 			uiDefButF(block, NUM, 0, "",		xco+80+(width-115)/3, yco-65, (width-115)/3, 19, &coa->maxrot[1], -2000.0, 2000.0, 10, 0, "Y component of reference direction");
 			uiDefButF(block, NUM, 0, "",		xco+80+2*(width-115)/3, yco-65, (width-115)/3, 19, &coa->maxrot[2], -2000.0, 2000.0, 10, 0, "Z component of reference direction");
 
-			uiDefButS(block, NUM, 0, "time", xco+10, yco-84, 70+(width-115)/3, 19, &(coa->time), 0.0, 1000.0, 0, 0, "Maximum activation time in frame, 0 for unlimited");
+			uiDefButS(block, NUM, 0, "time", xco+10, yco-84, 70, 19, &(coa->time), 0.0, 1000.0, 0, 0, "Maximum activation time in frame, 0 for unlimited");
+			uiDefButF(block, NUM, 0, "min", xco+80, yco-84, (width-115)/2, 19, &(coa->minloc[0]), 0.0, 180.0, 10, 1, "Minimum angle (in degree) to maintain with target direction. No correction is done if angle with target direction is between min and max");
+			uiDefButF(block, NUM, 0, "max", xco+80+(width-115)/2, yco-84, (width-115)/2, 19, &(coa->maxloc[0]), 0.0, 180.0, 10, 1, "Maximum angle (in degree) allowed with target direction. No correction is done if angle with target direction is between min and max");
 		}
 		str= "Constraint Type %t|Location %x0|Distance %x1|Orientation %x2";
 		but = uiDefButS(block, MENU, B_REDR, str,		xco+40, yco-23, (width-80), 19, &coa->type, 0.0, 0.0, 0, 0, "");
@@ -2536,11 +2538,7 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
 				break;
 			case ACT_2DFILTER_CUSTOMFILTER:
 				uiDefButI(block, NUM, B_REDR, "Pass Number:", xco+30,yco-44,width-60,19,&tdfa->int_arg,0.0,MAX_RENDER_PASS-1,0.0,0.0,"Set motion blur value");
-				uiDefIDPoinBut(block, test_scriptpoin_but, ID_SCRIPT, 1, "Script: ", xco+30,yco-64,width/2-32, 19, &tdfa->text, "");
-				uiDefButS(block, TOG|BIT|0, B_REDR, "Depth", xco+width/2+2 , yco - 64, width/4-16 , 19,
-						&tdfa->texture_flag, 0.0, 0.0, 0, 0, "Includes Depth Texture (bgl_DepthTexture)");
-				uiDefButS(block, TOG|BIT|1, B_REDR, "Luminance", xco+3*width/4-14 , yco - 64, width/4-16 , 19,
-						&tdfa->texture_flag, 0.0, 0.0, 0, 0, "Includes Luminance Texture (bgl_LuminanceTexture)");
+				uiDefIDPoinBut(block, test_scriptpoin_but, ID_SCRIPT, 1, "Script: ", xco+30,yco-64,width-60, 19, &tdfa->text, "");
 				break;
 		}
 		
diff --git a/source/blender/src/buttons_scene.c b/source/blender/src/buttons_scene.c
index af90d01fb59..8b35f90ea9d 100644
--- a/source/blender/src/buttons_scene.c
+++ b/source/blender/src/buttons_scene.c
@@ -137,36 +137,42 @@ static void load_new_sample(char *str)	/* called from fileselect */
 	bSample *sample, *newsample;
 
 	sound = G.buts->lockpoin;
+	
+	/* No Sound or Selected the same sample as we alredy have, just ignore */
+	if (sound==NULL || str==sound->name)
+		return;
+		
+	if (sizeof(sound->sample->name) < strlen(str)) {
+		error("Path too long: %s", str);
+		return;
+	}
+		
+	// save values
+	sample = sound->sample;
+	strcpy(name, sound->sample->name);	
+	strcpy(sound->name, str);
+	sound_set_sample(sound, NULL);
+	sound_initialize_sample(sound);
 
-	if (sound) {
-		// save values
-		sample = sound->sample;
-		strcpy(name, sound->sample->name);
-
-		strcpy(sound->name, str);
-		sound_set_sample(sound, NULL);
-		sound_initialize_sample(sound);
-
-		if (sound->sample->type == SAMPLE_INVALID) {
-			error("Not a valid sample: %s", str);
+	if (sound->sample->type == SAMPLE_INVALID) {
+		error("Not a valid sample: %s", str);
 
-			newsample = sound->sample;
+		newsample = sound->sample;
 
-			// restore values
-			strcpy(sound->name, name);
-			sound_set_sample(sound, sample);
+		// restore values
+		strcpy(sound->name, name);
+		sound_set_sample(sound, sample);
 
-			// remove invalid sample
+		// remove invalid sample
 
-			sound_free_sample(newsample);
-			BLI_remlink(samples, newsample);
-			MEM_freeN(newsample);
-		}
+		sound_free_sample(newsample);
+		BLI_remlink(samples, newsample);
+		MEM_freeN(newsample);
+		return;
 	}
-
+	
 	BIF_undo_push("Load new audio file");
 	allqueue(REDRAWBUTSSCENE, 0);
-
 }
 
 
@@ -403,7 +409,7 @@ static void sound_panel_sound(bSound *sound)
 		sample = sound->sample;
 
 		/* info string */
-		if (sound->sample && sound->sample->len) {
+		if (sound->sample && sound->sample->len && sound->sample->channels && sound->sample->bits) {
 			char *tmp;
 			if (sound->sample->channels == 1) tmp= "Mono";
 			else if (sound->sample->channels == 2) tmp= "Stereo";
@@ -1174,18 +1180,18 @@ static void seq_panel_proxy()
 			     130,140,120,19, &last_seq->flag, 
 			     0.0, 21.0, 100, 0, 
 			     "Use a custom directory to store data");
-	}
 
-	if (last_seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
-		uiDefIconBut(block, BUT, B_SEQ_SEL_PROXY_DIR, 
-			     ICON_FILESEL, 10, 120, 20, 20, 0, 0, 0, 0, 0, 
-			     "Select the directory/name for "
-			     "the proxy storage");
+		if (last_seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
+			uiDefIconBut(block, BUT, B_SEQ_SEL_PROXY_DIR, 
+				     ICON_FILESEL, 10, 120, 20, 20, 0, 0, 0, 0, 0, 
+				     "Select the directory/name for "
+				     "the proxy storage");
 
-		uiDefBut(block, TEX, 
-			 B_SEQ_BUT_RELOAD, "Dir: ", 
-			 30,120,220,20, last_seq->strip->proxy->dir, 
-			 0.0, 160.0, 100, 0, "");
+			uiDefBut(block, TEX, 
+				 B_SEQ_BUT_RELOAD, "Dir: ", 
+				 30,120,220,20, last_seq->strip->proxy->dir, 
+				 0.0, 160.0, 100, 0, "");
+		}
 	}
 
 	if (last_seq->flag & SEQ_USE_PROXY) {
@@ -2108,7 +2114,8 @@ static void render_panel_output(void)
 	/* Toon shading buttons */
 	uiBlockBeginAlign(block);
 	uiDefButBitI(block, TOG, R_EDGE, B_NOP,"Edge",   115, 89, 60, 20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Toon Edge-enhance");
-	uiDefBlockBut(block, edge_render_menu, NULL, "Edge Settings", 175, 89, 135, 20, "Display Edge settings");
+	uiDefBlockBut(block, edge_render_menu, NULL, "Edge Settings", 175, 89, 75, 20, "Display Edge settings");
+	uiDefButBitI(block, TOG, R_EDGE_FRS, B_NOP,"Freestyle",   250, 89, 60, 20, &G.scene->r.mode, 0, 0, 0, 0, "Enable Freestyle");
 	uiBlockEndAlign(block);
 	
 	uiBlockBeginAlign(block);
@@ -2209,10 +2216,10 @@ static void render_panel_render(void)
 	uiDefBut(block, BUT,B_DORENDER,"RENDER",	369, 164, 191,37, 0, 0, 0, 0, 0, "Render the current frame (F12)");
 #ifndef DISABLE_YAFRAY
 	/* yafray: on request, render engine menu is back again, and moved to Render panel */
-	uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0|YafRay %x1", 
+	uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0|YafRay %x1|Freestyle %x2", 
 												369, 142, 191, 20, &G.scene->r.renderer, 0, 0, 0, 0, "Choose rendering engine");	
 #else
-	uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0", 
+	uiDefButS(block, MENU, B_SWITCHRENDER, "Rendering Engine %t|Blender Internal %x0|Freestyle %x1", 
 												369, 142, 191, 20, &G.scene->r.renderer, 0, 0, 0, 0, "Choose rendering engine");	
 #endif /* disable yafray */
 
@@ -3384,8 +3391,10 @@ static void render_panel_layers(void)
 	uiDefButBitI(block, TOG, SCE_LAY_HALO, B_NOP,"Halo",	95,  85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Halos in this Layer (on top of Solid)");	
 	uiDefButBitI(block, TOG, SCE_LAY_ZTRA, B_NOP,"Ztra",	135, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Z-Transparent faces in this Layer (On top of Solid and Halos)");	
 	uiDefButBitI(block, TOG, SCE_LAY_SKY, B_NOP,"Sky",		175, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Sky or backbuffer in this Layer");	
-	uiDefButBitI(block, TOG, SCE_LAY_EDGE, B_NOP,"Edge",	215, 85, 45, 20, &srl->layflag, 0, 0, 0, 0, "Render Edge-enhance in this Layer (only works for Solid faces)");	
-	uiDefButBitI(block, TOG, SCE_LAY_STRAND, B_NOP,"Strand",260, 85, 50, 20, &srl->layflag, 0, 0, 0, 0, "Render Strands in this Layer");	
+	uiDefButBitI(block, TOG, SCE_LAY_EDGE, B_NOP,"Edge",	215, 85, 25, 20, &srl->layflag, 0, 0, 0, 0, "Render Edge-enhance in this Layer (only works for Solid faces)");
+	uiDefButBitI(block, TOG, SCE_LAY_FRS, B_NOP,"FrSt",	240, 85, 30, 20, &srl->layflag, 0, 0, 0, 0, "Render Freestyle in this Layer");	
+	uiDefButBitI(block, TOG, SCE_LAY_STRAND, B_NOP,"Strand",270, 85, 40, 20, &srl->layflag, 0, 0, 0, 0, "Render Strands in this Layer");	
+	
 	
 	uiDefIDPoinBut(block, test_grouppoin_but, ID_GR, B_SET_PASS, "Light:",	50, 65, 130, 20, &(srl->light_override), "Name of Group to use as Lamps instead");
 	uiDefIDPoinBut(block, test_matpoin_but, ID_MA, B_SET_PASS, "Mat:",	180, 65, 130, 20, &(srl->mat_override), "Name of Material to use as Materials instead");
diff --git a/source/blender/src/drawaction.c b/source/blender/src/drawaction.c
index 89466151a39..9b1af3f1a06 100644
--- a/source/blender/src/drawaction.c
+++ b/source/blender/src/drawaction.c
@@ -32,6 +32,7 @@
 
 #include <math.h>
 #include <stdlib.h>
+#include <string.h>
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -56,6 +57,8 @@
 #include "DNA_space_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_key_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_gpencil_types.h"
 
 #include "BKE_action.h"
 #include "BKE_depsgraph.h"
@@ -72,6 +75,7 @@
 #include "BIF_editnla.h"
 #include "BIF_interface.h"
 #include "BIF_interface_icons.h"
+#include "BIF_drawgpencil.h"
 #include "BIF_gl.h"
 #include "BIF_glutil.h"
 #include "BIF_resources.h"
@@ -81,6 +85,7 @@
 
 #include "BDR_drawaction.h"
 #include "BDR_editcurve.h"
+#include "BDR_gpencil.h"
 
 #include "BSE_drawnla.h"
 #include "BSE_drawipo.h"
@@ -620,6 +625,28 @@ static void draw_channel_names(void)
 					sprintf(name, "Constraint");
 				}
 					break;
+				case ACTTYPE_GPLAYER: /* gpencil layer */
+				{
+					bGPDlayer *gpl = (bGPDlayer *)ale->data;
+					
+					indent = 0;
+					special = -1;
+					expand = -1;
+						
+					if (EDITABLE_GPL(gpl))
+						protect = ICON_UNLOCKED;
+					else
+						protect = ICON_LOCKED;
+						
+					if (gpl->flag & GP_LAYER_HIDE)
+						mute = ICON_MUTE_IPO_ON;
+					else
+						mute = ICON_MUTE_IPO_OFF;
+					
+					sel = SEL_GPL(gpl);
+					BLI_snprintf(name, 32, gpl->info);
+				}
+					break;
 			}	
 
 			/* now, start drawing based on this information */
@@ -825,6 +852,12 @@ static void draw_channel_strips(void)
 					sel = SEL_ICU(icu);
 				}
 					break;
+				case ACTTYPE_GPLAYER:
+				{
+					bGPDlayer *gpl = (bGPDlayer *)ale->data;
+					sel = SEL_GPL(gpl);
+				}
+					break;
 			}
 			
 			if (datatype == ACTCONT_ACTION) {
@@ -863,6 +896,19 @@ static void draw_channel_strips(void)
 				glColor4ub(col2[0], col2[1], col2[2], 0x44);
 				glRectf(frame1_x, channel_y-CHANNELHEIGHT/2, G.v2d->hor.xmax,  channel_y+CHANNELHEIGHT/2);
 			}
+			else if (datatype == ACTCONT_GPENCIL) {
+				gla2DDrawTranslatePt(di, G.v2d->cur.xmin, y, &frame1_x, &channel_y);
+				
+				/* frames less than one get less saturated background */
+				if (sel) glColor4ub(col1[0], col1[1], col1[2], 0x22);
+				else glColor4ub(col2[0], col2[1], col2[2], 0x22);
+				glRectf(0, channel_y-CHANNELHEIGHT/2, frame1_x, channel_y+CHANNELHEIGHT/2);
+				
+				/* frames one and higher get a saturated background */
+				if (sel) glColor4ub(col1[0], col1[1], col1[2], 0x44);
+				else glColor4ub(col2[0], col2[1], col2[2], 0x44);
+				glRectf(frame1_x, channel_y-CHANNELHEIGHT/2, G.v2d->hor.xmax,  channel_y+CHANNELHEIGHT/2);
+			}
 		}
 		
 		/*	Increment the step */
@@ -897,6 +943,9 @@ static void draw_channel_strips(void)
 				case ALE_ICU:
 					draw_icu_channel(di, ale->key_data, y);
 					break;
+				case ALE_GPFRAME:
+					draw_gpl_channel(di, ale->data, y);
+					break;
 			}
 		}
 		
@@ -928,12 +977,55 @@ static void draw_channel_strips(void)
 void do_actionbuts(unsigned short event)
 {
 	switch(event) {
+		/* general */
 	case REDRAWVIEW3D:
 		allqueue(REDRAWVIEW3D, 0);
 		break;
 	case B_REDR:
 		allqueue(REDRAWACTION, 0);
 		break;
+		
+		/* action-groups */
+	case B_ACTCUSTCOLORS:	/* only when of the color wells is edited */
+	{
+		bActionGroup *agrp= get_active_actiongroup(G.saction->action);
+		
+		if (agrp)
+			agrp->customCol= -1;
+			
+		allqueue(REDRAWACTION, 0);
+	}
+		break;
+	case B_ACTCOLSSELECTOR: /* sync color set after using selector */
+	{
+		bActionGroup *agrp= get_active_actiongroup(G.saction->action);
+		
+		if (agrp) 
+			actionbone_group_copycolors(agrp, 1);
+			
+		allqueue(REDRAWACTION, 0);
+	}
+		break;
+	case B_ACTGRP_SELALL: /* select all grouped channels */
+	{
+		bAction *act= G.saction->action;
+		bActionGroup *agrp= get_active_actiongroup(act);
+		
+		/* select all in group, then reselect/activate group as the previous operation clears that */
+		select_action_group_channels(act, agrp);
+		agrp->flag |= (AGRP_ACTIVE|AGRP_SELECTED);
+		
+		allqueue(REDRAWACTION, 0);
+	}
+		break;
+	case B_ACTGRP_ADDTOSELF: /* add all selected action channels to self */
+		action_groups_group(0);
+		break;
+	case B_ACTGRP_UNGROUP: /* remove channels from active group */
+		// FIXME: todo...
+		printf("FIXME: remove achans from active Action-Group not implemented yet! \n");
+		break;
+	
 	}
 }
 
@@ -941,14 +1033,68 @@ void do_actionbuts(unsigned short event)
 static void action_panel_properties(short cntrl)	// ACTION_HANDLER_PROPERTIES
 {
 	uiBlock *block;
-
+	void *data;
+	short datatype;
+	
 	block= uiNewBlock(&curarea->uiblocks, "action_panel_properties", UI_EMBOSS, UI_HELV, curarea->win);
 	uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
 	uiSetPanelHandler(ACTION_HANDLER_PROPERTIES);  // for close and esc
-	if (uiNewPanel(curarea, block, "Transform Properties", "Action", 10, 230, 318, 204)==0) 
+	
+	/* get datatype */
+	data= get_action_context(&datatype);
+	//if (data == NULL) return;
+	
+	if (uiNewPanel(curarea, block, "Active Channel Properties", "Action", 10, 230, 318, 204)==0) 
 		return;
-
-	uiDefBut(block, LABEL, 0, "test text",		10,180,300,19, 0, 0, 0, 0, 0, "");
+	
+	/* currently, only show data for actions */
+	if (datatype == ACTCONT_ACTION) {
+		bActionGroup *agrp= get_active_actiongroup(data);
+		//bActionChannel *achan= get_hilighted_action_channel(data);
+		char *menustr;
+		
+		/* only for action-groups */
+		if (agrp) {
+			/* general stuff */
+			uiDefBut(block, LABEL, 1, "Action Group:",					10, 180, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
+			
+			uiDefBut(block, TEX, B_REDR, "Name: ",	10,160,150,20, agrp->name, 0.0, 31.0, 0, 0, "");
+			uiBlockBeginAlign(block);
+				uiDefButBitI(block, TOG, AGRP_EXPANDED, B_REDR, "Expanded", 170, 160, 75, 20, &agrp->flag, 0, 0, 0, 0, "Action Group is expanded");
+				uiDefButBitI(block, TOG, AGRP_PROTECTED, B_REDR, "Protected", 245, 160, 75, 20, &agrp->flag, 0, 0, 0, 0, "Action Group is protected");
+			uiBlockEndAlign(block);
+			
+			/* color stuff */
+			uiDefBut(block, LABEL, 1, "Group Colors:",	10, 107, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
+			uiBlockBeginAlign(block);
+				menustr= BIF_ThemeColorSetsPup(1);
+				uiDefButI(block, MENU,B_ACTCOLSSELECTOR, menustr, 10,85,150,19, &agrp->customCol, -1, 20, 0.0, 0.0, "Index of set of Custom Colors to shade Group's bones with. 0 = Use Default Color Scheme, -1 = Use Custom Color Scheme");						
+				MEM_freeN(menustr);
+				
+				/* show color-selection/preview */
+				if (agrp->customCol) {
+					/* do color copying/init (to stay up to date) */
+					actionbone_group_copycolors(agrp, 1);
+					
+					/* color changing */
+					uiDefButC(block, COL, B_ACTCUSTCOLORS, "",		10, 65, 50, 19, agrp->cs.active, 0, 0, 0, 0, "Color to use for 'top-level' channels");
+					uiDefButC(block, COL, B_ACTCUSTCOLORS, "",		60, 65, 50, 19, agrp->cs.select, 0, 0, 0, 0, "Color to use for '2nd-level' channels");
+					uiDefButC(block, COL, B_ACTCUSTCOLORS, "",		110, 65, 50, 19, agrp->cs.solid, 0, 0, 0, 0, "Color to use for '3rd-level' channels");
+				}
+			uiBlockEndAlign(block);
+			
+			/* commands for active group */
+			uiDefBut(block, BUT, B_ACTGRP_SELALL, "Select Grouped",	170,85,150,20, 0, 21, 0, 0, 0, "Select all action-channels belonging to this group (same as doing Ctrl-Shift-LMB)");
+			
+			uiBlockBeginAlign(block);
+				uiDefBut(block, BUT, B_ACTGRP_ADDTOSELF, "Add to Group",	170,60,150,20, 0, 21, 0, 0, 0, "Add selected action-channels to this group");
+				uiDefBut(block, BUT, B_ACTGRP_UNGROUP, "Un-Group",	170,40,150,20, 0, 21, 0, 0, 0, "Remove selected action-channels from this group (unimplemented)");
+			uiBlockEndAlign(block);
+		}
+	}
+	else {
+		/* Currently, there isn't anything to display for these types ... */
+	}
 }
 
 static void action_blockhandlers(ScrArea *sa)
@@ -976,6 +1122,7 @@ void drawactionspace(ScrArea *sa, void *spacedata)
 {
 	bAction *act = NULL;
 	Key *key = NULL;
+	bGPdata *gpd = NULL;
 	void *data;
 	short datatype;
 	
@@ -991,18 +1138,38 @@ void drawactionspace(ScrArea *sa, void *spacedata)
 
 	/* only try to refresh action that's displayed if not pinned */
 	if (G.saction->pin==0) {
-		if (OBACT)
-			G.saction->action = OBACT->action;
-		else
-			G.saction->action= NULL;
+		/* depends on mode */
+		switch (G.saction->mode) {
+			case SACTCONT_ACTION:
+			{
+				if (OBACT)
+					G.saction->action = OBACT->action;
+				else
+					G.saction->action= NULL;
+			}
+				break;
+			case SACTCONT_GPENCIL:
+			{
+				/* this searching could be slow (so users should pin after this is found) */
+				G.saction->gpd= gpencil_data_getetime(G.curscreen);
+			}
+				break;
+		}
 	}
 	
 	/* get data */
 	data = get_action_context(&datatype);
-	if (datatype == ACTCONT_ACTION)
-		act = data;
-	else if (datatype == ACTCONT_SHAPEKEY)
-		key = data;
+	switch (datatype) {
+		case ACTCONT_ACTION:
+			act = data;
+			break;
+		case ACTCONT_SHAPEKEY:
+			key = data;
+			break;
+		case ACTCONT_GPENCIL:
+			gpd = data;
+			break;
+	}
 	
 	/* Lets make sure the width of the left hand of the screen
 	 * is set to an appropriate value based on whether sliders
@@ -1351,10 +1518,15 @@ static ActKeysInc *init_aki_data()
 	static ActKeysInc aki;
 	
 	/* init data of static struct here */
-	if ((curarea->spacetype == SPACE_ACTION) && NLA_ACTION_SCALED)
+	if ((curarea->spacetype == SPACE_ACTION) && NLA_ACTION_SCALED &&
+		(G.saction->mode == SACTCONT_ACTION))
+	{
 		aki.ob= OBACT;
+	}
 	else if (curarea->spacetype == SPACE_NLA)
+	{
 		aki.ob= NULL; // FIXME
+	}
 	else
 		aki.ob= NULL;
 		
@@ -1429,6 +1601,16 @@ void draw_action_channel(gla2DDrawInfo *di, bAction *act, float ypos)
 	BLI_freelistN(&keys);
 }
 
+void draw_gpl_channel(gla2DDrawInfo *di, bGPDlayer *gpl, float ypos)
+{
+	ListBase keys = {0, 0};
+	ActKeysInc *aki = init_aki_data();
+	
+	gpl_to_keylist(gpl, &keys, NULL, aki);
+	draw_keylist(di, &keys, NULL, ypos);
+	BLI_freelistN(&keys);
+}
+
 /* --------------- Conversion: data -> keyframe list ------------------ */
 
 void ob_to_keylist(Object *ob, ListBase *keys, ListBase *blocks, ActKeysInc *aki)
@@ -1575,3 +1757,26 @@ void action_to_keylist(bAction *act, ListBase *keys, ListBase *blocks, ActKeysIn
 	}
 }
 
+void gpl_to_keylist(bGPDlayer *gpl, ListBase *keys, ListBase *blocks, ActKeysInc *aki)
+{
+	bGPDframe *gpf;
+	ActKeyColumn *ak;
+	
+	if (gpl && keys) {
+		/* loop over frames, converting directly to 'keyframes' (should be in order too) */
+		for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+			ak= MEM_callocN(sizeof(ActKeyColumn), "ActKeyColumn");
+			BLI_addtail(keys, ak);
+			
+			ak->cfra= gpf->framenum;
+			ak->modified = 1;
+			ak->handle_type= 0; 
+			
+			if (gpf->flag & GP_FRAME_SELECT)
+				ak->sel = SELECT;
+			else
+				ak->sel = 0;
+		}
+	}
+}
+
diff --git a/source/blender/src/drawgpencil.c b/source/blender/src/drawgpencil.c
new file mode 100644
index 00000000000..55d0464b9af
--- /dev/null
+++ b/source/blender/src/drawgpencil.c
@@ -0,0 +1,653 @@
+/**
+ * $Id: drawgpencil.c 14881 2008-05-18 10:41:42Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+ 
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <math.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BMF_Api.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+
+#include "DNA_listBase.h"
+#include "DNA_gpencil_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_view3d_types.h"
+
+#include "BKE_global.h"
+#include "BKE_utildefines.h"
+#include "BKE_blender.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+#include "BIF_butspace.h"
+#include "BIF_graphics.h"
+#include "BIF_interface.h"
+#include "BIF_mywindow.h"
+#include "BIF_resources.h"
+#include "BIF_space.h"
+#include "BIF_screen.h"
+#include "BIF_toolbox.h"
+#include "BIF_toets.h"
+
+#include "BDR_gpencil.h"
+#include "BIF_drawgpencil.h"
+
+#include "BSE_drawipo.h"
+#include "BSE_headerbuttons.h"
+#include "BSE_view.h"
+
+#include "blendef.h"
+#include "butspace.h"
+
+#include "PIL_time.h"			/* sleep				*/
+#include "mydevice.h"
+
+/* ************************************************** */
+/* GREASE PENCIL PANEL-UI DRAWING */
+
+/* Every space which implements Grease-Pencil functionality should have a panel
+ * for the settings. All of the space-dependent parts should be coded in the panel
+ * code for that space, but the rest is all handled by generic panel here.
+ */
+
+/* ------- Callbacks ----------- */
+/* These are just 'dummy wrappers' around gpencil api calls */
+
+/* make layer active one after being clicked on */
+void gp_ui_activelayer_cb (void *gpd, void *gpl)
+{
+	gpencil_layer_setactive(gpd, gpl);
+}
+
+/* rename layer and set active */
+void gp_ui_renamelayer_cb (void *gpd_arg, void *gpl_arg)
+{
+	bGPdata *gpd= (bGPdata *)gpd_arg;
+	bGPDlayer *gpl= (bGPDlayer *)gpl_arg;
+	
+	BLI_uniquename(&gpd->layers, gpl, "GP_Layer", offsetof(bGPDlayer, info[0]), 128);
+	gpencil_layer_setactive(gpd, gpl);
+}
+
+/* add a new layer */
+void gp_ui_addlayer_cb (void *gpd, void *dummy)
+{
+	gpencil_layer_addnew(gpd);
+}
+
+/* delete active layer */
+void gp_ui_dellayer_cb (void *gpd, void *dummy)
+{
+	gpencil_layer_delactive(gpd);
+}
+
+/* delete last stroke of active layer */
+void gp_ui_delstroke_cb (void *gpd, void *gpl)
+{
+	bGPDframe *gpf= gpencil_layer_getframe(gpl, CFRA, 0);
+	
+	gpencil_layer_setactive(gpd, gpl);
+	gpencil_frame_delete_laststroke(gpf);
+}
+
+/* delete active frame of active layer */
+void gp_ui_delframe_cb (void *gpd, void *gpl)
+{
+	bGPDframe *gpf= gpencil_layer_getframe(gpl, CFRA, 0);
+	
+	gpencil_layer_setactive(gpd, gpl);
+	gpencil_layer_delframe(gpl, gpf);
+}
+
+
+/* set this set of gpencil data for editing in action editor */
+void gp_ui_dotime_cb (void *gpd_arg, void *dummy)
+{
+	bGPdata *gpd= (bGPdata *)gpd_arg;
+	
+	/* check if setting or clearing (note: setting was just set...) */
+	if (gpd->flag & GP_DATA_EDITTIME)
+		gpencil_data_setetime(G.curscreen, gpd);
+	else	
+		gpencil_data_setetime(G.curscreen, NULL);
+}
+
+
+/* ------- Drawing Code ------- */
+
+/* draw the controls for a given layer */
+static void gp_drawui_layer (uiBlock *block, bGPdata *gpd, bGPDlayer *gpl, short *xco, short *yco)
+{
+	uiBut *but;
+	short width= 314;
+	short height;
+	int rb_col;
+	
+	/* unless button has own callback, it adds this callback to button */
+	uiBlockSetFunc(block, gp_ui_activelayer_cb, gpd, gpl);
+	
+	/* draw header */
+	{
+		uiBlockSetEmboss(block, UI_EMBOSSN);
+		
+		/* rounded header */
+		rb_col= (gpl->flag & GP_LAYER_ACTIVE)?50:20;
+		uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-8, *yco-2, width, 24, NULL, 5.0, 0.0, 15 , rb_col-20, ""); 
+		
+		/* lock toggle */
+		uiDefIconButBitI(block, ICONTOG, GP_LAYER_LOCKED, B_REDR, ICON_UNLOCKED,	*xco-7, *yco-1, 20, 20, &gpl->flag, 0.0, 0.0, 0, 0, "Layer cannot be modified");
+	}
+	
+	/* when layer is locked or hidden, don't draw the rest of its settings */
+	if (gpl->flag & (GP_LAYER_LOCKED|GP_LAYER_HIDE)) {
+		height= 26;
+		
+		/* draw rest of header */
+		{
+			/* visibility button (only if hidden but not locked!) */
+			if ((gpl->flag & GP_LAYER_HIDE) && !(gpl->flag & GP_LAYER_LOCKED))
+				uiDefIconButBitI(block, ICONTOG, GP_LAYER_HIDE, B_REDR, ICON_RESTRICT_VIEW_OFF,	*xco+12, *yco-1, 20, 20, &gpl->flag, 0.0, 0.0, 0, 0, "Visibility of layer");
+			
+			/* name */
+			uiDefBut(block, LABEL, 1, gpl->info,	*xco+35, *yco, 240, 20, NULL, 0.0, 0.0, 0, 0, "Short description of what this layer is for (optional)");
+		}
+		
+		/* draw backdrop */
+		uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-8, *yco-height, width, height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+		
+		/* draw settings... (i.e. just warning for this one) */
+		if (gpl->flag & GP_LAYER_HIDE)
+			uiDefBut(block, LABEL, 1, "Grease Pencil Layer Hidden",	*xco+60, *yco-26, 205, 20, NULL, 0.0, 0.0, 0, 0, "");
+		else
+			uiDefBut(block, LABEL, 1, "Grease Pencil Layer Locked",	*xco+60, *yco-26, 205, 20, NULL, 0.0, 0.0, 0, 0, "");
+			
+		uiBlockSetEmboss(block, UI_EMBOSS);
+	}
+	else {
+		height= 100;
+		
+		/* draw rest of header */
+		{
+			/* visibility button */
+			uiDefIconButBitI(block, ICONTOG, GP_LAYER_HIDE, B_REDR, ICON_RESTRICT_VIEW_OFF,	*xco+12, *yco-1, 20, 20, &gpl->flag, 0.0, 0.0, 0, 0, "Visibility of layer");
+			
+			uiBlockSetEmboss(block, UI_EMBOSS);
+			
+			/* name */
+			but= uiDefButC(block, TEX, B_REDR, "Info:",	*xco+35, *yco, 240, 20, gpl->info, 0, 127, 0, 0, "Short description of what this layer is for (optional)");
+			uiButSetFunc(but, gp_ui_renamelayer_cb, gpd, gpl);
+			
+			/* delete 'button' */
+			uiBlockSetEmboss(block, UI_EMBOSSN);
+			
+			but= uiDefIconBut(block, BUT, B_REDR, ICON_X, *xco+(width-30), *yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, "Delete layer");
+			uiButSetFunc(but, gp_ui_dellayer_cb, gpd, NULL);
+			
+			uiBlockSetEmboss(block, UI_EMBOSS);
+		}
+		
+		/* draw backdrop */
+		uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-8, *yco-height, width, height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
+		
+		/* draw settings */
+		{
+			/* color */
+			uiBlockBeginAlign(block);
+				uiDefButF(block, COL, B_REDR, "",		*xco, *yco-26, 150, 19, gpl->color, 0, 0, 0, 0, "Color to use for all strokes on this Grease Pencil Layer");
+				uiDefButF(block, NUMSLI, B_REDR, "Opacity: ",		*xco,*yco-45,150,19, &gpl->color[3], 0.3, 1.0, 0, 0, "Visibility of stroke (0.3 to 1.0)");
+			uiBlockEndAlign(block);
+			
+			/* stroke thickness */
+			uiDefButS(block, NUMSLI, B_REDR, "Thickness:",	*xco, *yco-75, 150, 20, &gpl->thickness, 1, 10, 0, 0, "Thickness of strokes (in pixels)");
+			
+			
+			/* onion-skinning */
+			uiBlockBeginAlign(block);
+				uiDefButBitI(block, TOG, GP_LAYER_ONIONSKIN, B_REDR, "Onion-Skin", *xco+160, *yco-26, 140, 20, &gpl->flag, 0, 0, 0, 0, "Ghost frames on either side of frame");
+				uiDefButS(block, NUMSLI, B_REDR, "GStep:",	*xco+160, *yco-46, 140, 20, &gpl->gstep, 0, 120, 0, 0, "Maximum frame range on either side of active frame to show (0 = just 'first' available frame on either side)");
+			uiBlockEndAlign(block);
+			
+			/* options */
+			but= uiDefBut(block, BUT, B_REDR, "Del Active Frame", *xco+160, *yco-75, 140, 20, NULL, 0, 0, 0, 0, "Erases the the active frame for this layer");
+			uiButSetFunc(but, gp_ui_delframe_cb, gpd, gpl);
+			
+			but= uiDefBut(block, BUT, B_REDR, "Del Last Stroke", *xco+160, *yco-95, 140, 20, NULL, 0, 0, 0, 0, "Erases the last stroke from the active frame");
+			uiButSetFunc(but, gp_ui_delstroke_cb, gpd, gpl);
+			
+			//uiDefButBitI(block, TOG, GP_LAYER_DRAWDEBUG, B_REDR, "Show Points", *xco+160, *yco-75, 130, 20, &gpl->flag, 0, 0, 0, 0, "Show points which form the strokes");
+		}
+	}
+	
+	/* adjust height for new to start */
+	(*yco) -= (height + 27); 
+} 
+
+/* Draw the contents for a grease-pencil panel. This assumes several things:
+ * 	- that panel has been created, is 318 x 204. max yco is 225
+ *	- that a toggle for turning on/off gpencil drawing is 150 x 20, starting from (10,225)
+ * It will return the amount of extra space to extend the panel by
+ */
+short draw_gpencil_panel (uiBlock *block, bGPdata *gpd, ScrArea *sa)
+{
+	uiBut *but;
+	bGPDlayer *gpl;
+	short xco= 10, yco= 155;
+	
+	/* draw gpd settings first */
+	{
+		/* show status info button */
+		uiDefButBitI(block, TOG, GP_DATA_DISPINFO, B_REDR, "Show Status Info", 10, 205, 150, 20, &gpd->flag, 0, 0, 0, 0, "Display status info about current status of Grease Pencil");
+		
+		/* add new/duplicate layer buttons */
+		but= uiDefBut(block, BUT, B_REDR, "Add New Layer", 10,182,150,20, 0, 0, 0, 0, 0, "Adds a new Grease Pencil Layer");
+		uiButSetFunc(but, gp_ui_addlayer_cb, gpd, NULL);
+		
+		
+		/* show override lmb-clicks button */
+		uiDefButBitI(block, TOG, GP_DATA_EDITPAINT, B_REDR, "Draw Mode", 170, 225, 150, 20, &gpd->flag, 0, 0, 0, 0, "Interpret LMB-click as new strokes (same as holding Shift-Key per stroke)");
+		
+		/* 'view align' button (naming depends on context) */
+		if (sa->spacetype == SPACE_VIEW3D)
+			uiDefButBitI(block, TOG, GP_DATA_VIEWALIGN, B_REDR, "Draw in 3D", 170, 205, 150, 20, &gpd->flag, 0, 0, 0, 0, "New strokes are added in 3D-space");
+		else if (sa->spacetype != SPACE_SEQ) /* not available for sequencer yet */
+			uiDefButBitI(block, TOG, GP_DATA_VIEWALIGN, B_REDR, "Stick to View", 170, 205, 150, 20, &gpd->flag, 0, 0, 0, 0, "New strokes are added on 2d-canvas");
+		
+		/* show edit-in-action button */
+		but= uiDefButBitI(block, TOG, GP_DATA_EDITTIME, B_REDR, "Edit Timing", 170, 182, 150, 20, &gpd->flag, 0, 0, 0, 0, "Edit timing of frames for the Grease Pencil block");
+		uiButSetFunc(but, gp_ui_dotime_cb, gpd, NULL);
+	}
+	
+	/* draw for each layer */
+	for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+		gp_drawui_layer(block, gpd, gpl, &xco, &yco);
+	}
+	
+	/* return new height if necessary */
+	return (yco < 0) ? (204 - yco) : 204;
+}	
+
+/* ************************************************** */
+/* GREASE PENCIL DRAWING */
+
+/* flags for sflag */
+enum {
+	GP_DRAWDATA_NOSTATUS 	= (1<<0),	/* don't draw status info */
+	GP_DRAWDATA_ONLY3D		= (1<<1),	/* only draw 3d-strokes */
+	GP_DRAWDATA_ONLYV2D		= (1<<2),	/* only draw 'canvas' strokes */
+};
+
+/* draw a given stroke */
+static void gp_draw_stroke (bGPDspoint *points, int totpoints, short thickness, short dflag, short sflag, short debug, int winx, int winy)
+{
+	bGPDspoint *pt;
+	int i;
+	
+	/* error checking */
+	if ((points == NULL) || (totpoints <= 0))
+		return;
+	
+	/* check if stroke can be drawn */
+	if ((dflag & GP_DRAWDATA_ONLY3D) && !(sflag & GP_STROKE_3DSPACE))
+		return;
+	if (!(dflag & GP_DRAWDATA_ONLY3D) && (sflag & GP_STROKE_3DSPACE))
+		return;
+	if ((dflag & GP_DRAWDATA_ONLYV2D) && !(sflag & GP_STROKE_2DSPACE))
+		return;
+	if (!(dflag & GP_DRAWDATA_ONLYV2D) && (sflag & GP_STROKE_2DSPACE))
+		return;
+	
+	/* if drawing a single point, draw it larger */
+	if (totpoints == 1) {		
+		/* draw point */
+		if (sflag & GP_STROKE_3DSPACE) {
+			glBegin(GL_POINTS);
+				glVertex3f(points->x, points->y, points->z);
+			glEnd();
+		}
+		else if (sflag & GP_STROKE_2DSPACE) {
+			glBegin(GL_POINTS);
+				glVertex2f(points->x, points->y);
+			glEnd();
+		}
+		else {
+			const float x= (points->x / 1000 * winx);
+			const float y= (points->y / 1000 * winy);
+			
+			glBegin(GL_POINTS);
+				glVertex2f(x, y);
+			glEnd();
+		}
+	}
+	else {
+		float oldpressure = 0.0f;
+		
+		/* draw stroke curve */
+		glBegin(GL_LINE_STRIP);
+		for (i=0, pt=points; i < totpoints && pt; i++, pt++) {
+			float x, y, z;
+			
+			if (sflag & GP_STROKE_3DSPACE) {
+				x= pt->x;
+				y= pt->y;
+				z= pt->z;
+			}
+			else if (sflag & GP_STROKE_2DSPACE) {
+				x= pt->x;
+				y= pt->y;
+				z= 0;
+			}
+			else {
+				x= (pt->x / 1000 * winx);
+				y= (pt->y / 1000 * winy);
+				z= 0;
+			}
+			
+			if (fabs(pt->pressure - oldpressure) > 0.2f) {
+				glEnd();
+				glLineWidth(pt->pressure * thickness);
+				glBegin(GL_LINE_STRIP);
+				
+				if (sflag & GP_STROKE_3DSPACE) 
+					glVertex3f(x, y, z);
+				else
+					glVertex2f(x, y);
+				
+				oldpressure = pt->pressure;
+			}
+			else {
+				if (sflag & GP_STROKE_3DSPACE) 
+					glVertex3f(x, y, z);
+				else
+					glVertex2f(x, y);
+			}
+		}
+		glEnd();
+		
+		/* draw debug points of curve on top? */
+		if (debug) {
+			glBegin(GL_POINTS);
+			for (i=0, pt=points; i < totpoints && pt; i++, pt++) {
+				if (sflag & GP_STROKE_3DSPACE) {
+					glVertex3f(pt->x, pt->y, pt->z);
+				}
+				else if (sflag & GP_STROKE_2DSPACE) {
+					glVertex2f(pt->x, pt->y);
+				}
+				else {
+					const float x= (pt->x / 1000 * winx);
+					const float y= (pt->y / 1000 * winy);
+					
+					glVertex2f(x, y);
+				}
+			}
+			glEnd();
+		}
+	}
+}
+
+/* draw grease-pencil datablock */
+static void gp_draw_data (bGPdata *gpd, int winx, int winy, int dflag)
+{
+	bGPDlayer *gpl, *actlay=NULL;
+	
+	/* turn on smooth lines (i.e. anti-aliasing) */
+	glEnable(GL_LINE_SMOOTH);
+	
+	/* turn on alpha-blending */
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glEnable(GL_BLEND);
+		
+	/* loop over layers, drawing them */
+	for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+		bGPDframe *gpf;
+		bGPDstroke *gps;
+		
+		short debug = (gpl->flag & GP_LAYER_DRAWDEBUG) ? 1 : 0;
+		short lthick= gpl->thickness;
+		float color[4];
+		
+		/* don't draw layer if hidden */
+		if (gpl->flag & GP_LAYER_HIDE) 
+			continue;
+		
+		/* if layer is active one, store pointer to it */
+		if (gpl->flag & GP_LAYER_ACTIVE)
+			actlay= gpl;
+		
+		/* get frame to draw */
+		gpf= gpencil_layer_getframe(gpl, CFRA, 0);
+		if (gpf == NULL) 
+			continue;
+		
+		/* set color, stroke thickness, and point size */
+		glLineWidth(lthick);
+		QUATCOPY(color, gpl->color); // just for copying 4 array elements
+		glColor4f(color[0], color[1], color[2], color[3]);
+		glPointSize(gpl->thickness + 2);
+		
+		/* draw 'onionskins' (frame left + right) */
+		if (gpl->flag & GP_LAYER_ONIONSKIN) {
+			/* drawing method - only immediately surrounding (gstep = 0), or within a frame range on either side (gstep > 0)*/			
+			if (gpl->gstep) {
+				bGPDframe *gf;
+				short i;
+				
+				/* draw previous frames first */
+				for (gf=gpf->prev, i=0; gf; gf=gf->prev, i++) {
+					/* check if frame is drawable */
+					if ((gpf->framenum - gf->framenum) <= gpl->gstep) {
+						/* alpha decreases with distance from curframe index */
+						glColor4f(color[0], color[1], color[2], (color[3]-(i*0.7)));
+						
+						for (gps= gf->strokes.first; gps; gps= gps->next) {	
+							gp_draw_stroke(gps->points, gps->totpoints, lthick, dflag, gps->flag, debug, winx, winy);
+						}
+					}
+					else 
+						break;
+				}
+				
+				/* now draw next frames */
+				for (gf= gpf->next, i=0; gf; gf=gf->next, i++) {
+					/* check if frame is drawable */
+					if ((gf->framenum - gpf->framenum) <= gpl->gstep) {
+						/* alpha decreases with distance from curframe index */
+						glColor4f(color[0], color[1], color[2], (color[3]-(i*0.7)));
+						
+						for (gps= gf->strokes.first; gps; gps= gps->next) {								
+							gp_draw_stroke(gps->points, gps->totpoints, lthick, dflag, gps->flag, debug, winx, winy);
+						}
+					}
+					else 
+						break;
+				}	
+				
+				/* restore alpha */
+				glColor4f(color[0], color[1], color[2], color[3]);
+			}
+			else {
+				/* draw the strokes for the ghost frames (at half of the alpha set by user) */
+				glColor4f(color[0], color[1], color[2], (color[3] / 7));
+				
+				if (gpf->prev) {
+					for (gps= gpf->prev->strokes.first; gps; gps= gps->next) {
+						gp_draw_stroke(gps->points, gps->totpoints, lthick, dflag, gps->flag, debug, winx, winy);
+					}
+				}
+				
+				glColor4f(color[0], color[1], color[2], (color[3] / 4));
+				if (gpf->next) {
+					for (gps= gpf->next->strokes.first; gps; gps= gps->next) {	
+						gp_draw_stroke(gps->points, gps->totpoints, lthick, dflag, gps->flag, debug, winx, winy);
+					}
+				}
+				
+				/* restore alpha */
+				glColor4f(color[0], color[1], color[2], color[3]);
+			}
+		}
+		
+		/* draw the strokes already in active frame */
+		for (gps= gpf->strokes.first; gps; gps= gps->next) {	
+			gp_draw_stroke(gps->points, gps->totpoints, lthick, dflag, gps->flag, debug, winx, winy);
+		}
+		
+		/* Check if may need to draw the active stroke cache, only if this layer is the active layer
+		 * that is being edited. (Stroke cache is currently stored in gp-data)
+		 */
+		if ((G.f & G_GREASEPENCIL) && (gpl->flag & GP_LAYER_ACTIVE) &&
+			(gpf->flag & GP_FRAME_PAINT)) 
+		{
+			/* Buffer stroke needs to be drawn with a different linestyle to help differentiate them from normal strokes. */
+			setlinestyle(2);
+			gp_draw_stroke(gpd->sbuffer, gpd->sbuffer_size, lthick, dflag, gpd->sbuffer_sflag, debug, winx, winy);
+			setlinestyle(0);
+		}
+	}
+	
+	/* turn off alpha blending, then smooth lines */
+	glDisable(GL_BLEND); // alpha blending
+	glDisable(GL_LINE_SMOOTH); // smooth lines
+	
+	/* show info for debugging the status of gpencil */
+	if ( ((dflag & GP_DRAWDATA_NOSTATUS)==0) && (gpd->flag & GP_DATA_DISPINFO) ) {
+		char printable[256];
+		short xmax;
+		
+		/* get text to display */
+		if (actlay) {
+			if (gpd->flag & GP_DATA_EDITPAINT)
+				BIF_ThemeColor(TH_BONE_POSE); // should be blue-ish
+			else if (actlay->actframe == NULL)
+				BIF_ThemeColor(TH_REDALERT);
+			else if (actlay->actframe->framenum == CFRA)
+				BIF_ThemeColor(TH_VERTEX_SELECT); // should be yellow
+			else
+				BIF_ThemeColor(TH_TEXT_HI);
+			
+			if (actlay->actframe) {
+				sprintf(printable, "GPencil: Layer ('%s'), Frame (%d) %s", 
+					actlay->info, actlay->actframe->framenum,
+					((gpd->flag & GP_DATA_EDITPAINT)?", Draw Mode On":"") );
+			}
+			else {
+				sprintf(printable, "GPencil: Layer ('%s'), Frame <None> %s", 
+					actlay->info, ((gpd->flag & GP_DATA_EDITPAINT)?", Draw Mode On":"") );
+			}
+		}
+		else {
+			BIF_ThemeColor(TH_REDALERT);
+			sprintf(printable, "GPencil: Layer <None>");
+		}
+		xmax= GetButStringLength(printable);
+		
+		/* only draw it if view is wide enough (assume padding of 20 is enough for now) */
+		if (winx > (xmax + 20)) { 
+			glRasterPos2i(winx-xmax, winy-20);
+			BMF_DrawString(G.fonts, printable);
+		}
+	}
+	
+	/* restore initial gl conditions */
+	glLineWidth(1.0);
+	glPointSize(1.0);
+	glColor4f(0, 0, 0, 1);
+}
+
+/* ----------- */
+
+/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly 
+ * Note: this gets called twice - first time with onlyv2d=1 to draw 'canvas' strokes, second time with onlyv2d=0 for screen-aligned strokes
+ */
+void draw_gpencil_2dview (ScrArea *sa, short onlyv2d)
+{
+	bGPdata *gpd;
+	int dflag = 0;
+	
+	/* check that we have grease-pencil stuff to draw */
+	if (sa == NULL) return;
+	gpd= gpencil_data_getactive(sa);
+	if (gpd == NULL) return;
+	
+	/* draw it! */
+	if (onlyv2d) dflag |= (GP_DRAWDATA_ONLYV2D|GP_DRAWDATA_NOSTATUS);
+	gp_draw_data(gpd, sa->winx, sa->winy, dflag);
+}
+
+/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly 
+ * Note: this gets called twice - first time with only3d=1 to draw 3d-strokes, second time with only3d=0 for screen-aligned strokes
+ */
+void draw_gpencil_3dview (ScrArea *sa, short only3d)
+{
+	bGPdata *gpd;
+	int dflag = 0;
+	
+	/* check that we have grease-pencil stuff to draw */
+	gpd= gpencil_data_getactive(sa);
+	if (gpd == NULL) return;
+	
+	/* draw it! */
+	if (only3d) dflag |= (GP_DRAWDATA_ONLY3D|GP_DRAWDATA_NOSTATUS);
+	gp_draw_data(gpd, sa->winx, sa->winy, dflag);
+}
+
+/* draw grease-pencil sketches to opengl render window assuming that matrices are already set correctly */
+void draw_gpencil_oglrender (View3D *v3d, int winx, int winy)
+{
+	bGPdata *gpd;
+	
+	/* assume gpencil data comes from v3d */
+	if (v3d == NULL) return;
+	gpd= v3d->gpd;
+	if (gpd == NULL) return;
+	
+	/* pass 1: draw 3d-strokes ------------ > */
+	gp_draw_data(gpd, winx, winy, (GP_DRAWDATA_NOSTATUS|GP_DRAWDATA_ONLY3D));
+	
+	/* pass 2: draw 2d-strokes ------------ > */
+		/* adjust view matrices */
+	myortho2(-0.375, (float)(winx)-0.375, -0.375, (float)(winy)-0.375);
+	glLoadIdentity();
+	
+		/* draw it! */
+	gp_draw_data(gpd, winx, winy, GP_DRAWDATA_NOSTATUS);
+}
+
+/* ************************************************** */
diff --git a/source/blender/src/drawnode.c b/source/blender/src/drawnode.c
index 1169062fdd0..3a73ee84ead 100644
--- a/source/blender/src/drawnode.c
+++ b/source/blender/src/drawnode.c
@@ -37,6 +37,7 @@
 #include "DNA_action_types.h"
 #include "DNA_color_types.h"
 #include "DNA_customdata_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_ipo_types.h"
 #include "DNA_ID.h"
 #include "DNA_image_types.h"
@@ -65,8 +66,11 @@
 #include "CMP_node.h"
 #include "SHD_node.h"
 
+#include "BDR_gpencil.h"
+
 #include "BIF_gl.h"
 #include "BIF_glutil.h"
+#include "BIF_drawgpencil.h"
 #include "BIF_interface.h"
 #include "BIF_interface_icons.h"
 #include "BIF_language.h"
@@ -3300,6 +3304,66 @@ static void node_draw_group(ScrArea *sa, SpaceNode *snode, bNode *gnode)
 }
 
 
+
+static void nodes_panel_gpencil(short cntrl)	// NODES_HANDLER_GREASEPENCIL
+{
+	uiBlock *block;
+	SpaceNode *snode;
+	
+	snode= curarea->spacedata.first;
+
+	block= uiNewBlock(&curarea->uiblocks, "nodes_panel_gpencil", UI_EMBOSS, UI_HELV, curarea->win);
+	uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE  | cntrl);
+	uiSetPanelHandler(NODES_HANDLER_GREASEPENCIL);  // for close and esc
+	if (uiNewPanel(curarea, block, "Grease Pencil", "SpaceNode", 100, 30, 318, 204)==0) return;
+	
+	/* we can only really draw stuff if there are nodes (otherwise no events are handled */
+	if (snode->nodetree == NULL)
+		return;
+	
+	/* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
+	if (snode->flag & SNODE_DISPGP) {
+		if (snode->gpd == NULL)
+			gpencil_data_setactive(curarea, gpencil_data_addnew());
+	}
+	
+	if (snode->flag & SNODE_DISPGP) {
+		bGPdata *gpd= snode->gpd;
+		short newheight;
+		
+		/* this is a variable height panel, newpanel doesnt force new size on existing panels */
+		/* so first we make it default height */
+		uiNewPanelHeight(block, 204);
+		
+		/* draw button for showing gpencil settings and drawings */
+		uiDefButBitS(block, TOG, SNODE_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &snode->flag, 0, 0, 0, 0, "Display freehand annotations overlay over this Node Editor");
+		
+		/* extend the panel if the contents won't fit */
+		newheight= draw_gpencil_panel(block, gpd, curarea); 
+		uiNewPanelHeight(block, newheight);
+	}
+	else {
+		uiDefButBitS(block, TOG, SNODE_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &snode->flag, 0, 0, 0, 0, "Display freehand annotations overlay over this Node Editor");
+		uiDefBut(block, LABEL, 1, " ",	160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
+	}
+}
+
+static void nodes_blockhandlers(ScrArea *sa)
+{
+	SpaceNode *snode= sa->spacedata.first;
+	short a;
+	
+	for(a=0; a<SPACE_MAXHANDLER; a+=2) {
+		/* clear action value for event */
+		switch(snode->blockhandler[a]) {
+			case NODES_HANDLER_GREASEPENCIL:
+				nodes_panel_gpencil(snode->blockhandler[a+1]);
+				break;
+		}
+	}
+	uiDrawBlocksPanels(sa, 0);
+}
+
 void drawnodespace(ScrArea *sa, void *spacedata)
 {
 	SpaceNode *snode= sa->spacedata.first;
@@ -3354,13 +3418,26 @@ void drawnodespace(ScrArea *sa, void *spacedata)
 		}
 	}
 	
+	/* draw grease-pencil ('canvas' strokes) */
+	if ((snode->flag & SNODE_DISPGP) && (snode->nodetree))
+		draw_gpencil_2dview(sa, 1);
+	
 	/* restore viewport (not needed yet) */
 	mywinset(sa->win);
 
 	/* ortho at pixel level curarea */
 	myortho2(-0.375, sa->winx-0.375, -0.375, sa->winy-0.375);
+	
+	/* draw grease-pencil (screen strokes) */
+	if ((snode->flag & SNODE_DISPGP) && (snode->nodetree))
+		draw_gpencil_2dview(sa, 0);
 
 	draw_area_emboss(sa);
+	
+	/* it is important to end a view in a transform compatible with buttons */
+	bwin_scalematrix(sa->win, snode->blockscale, snode->blockscale, snode->blockscale);
+	nodes_blockhandlers(sa);
+	
 	curarea->win_swap= WIN_BACK_OK;
 	
 	/* in the end, this is a delayed previewrender test, to allow buttons to be first */
diff --git a/source/blender/src/drawobject.c b/source/blender/src/drawobject.c
index 045bf292446..1a469e8b366 100644
--- a/source/blender/src/drawobject.c
+++ b/source/blender/src/drawobject.c
@@ -1199,7 +1199,12 @@ static void drawlattice(Object *ob)
 	int use_wcol= 0;
 
 	lt= (ob==G.obedit)?editLatt:ob->data;
+	
+	/* now we default make displist, this will modifiers work for non animated case */
+	if(ob->disp.first==NULL)
+		lattice_calc_modifiers(ob);
 	dl= find_displist(&ob->disp, DL_VERTS);
+	
 	if(ob==G.obedit) {
 		cpack(0x004000);
 		
diff --git a/source/blender/src/drawseq.c b/source/blender/src/drawseq.c
index e554b91dd52..c8c74ad8279 100644
--- a/source/blender/src/drawseq.c
+++ b/source/blender/src/drawseq.c
@@ -43,6 +43,7 @@
 
 #include "IMB_imbuf_types.h"
 
+#include "DNA_gpencil_types.h"
 #include "DNA_sequence_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
@@ -67,6 +68,9 @@
 #include "BIF_space.h"
 #include "BIF_interface.h"
 
+#include "BIF_drawgpencil.h"
+#include "BDR_gpencil.h"
+
 #include "BSE_view.h"
 #include "BSE_drawipo.h"
 #include "BSE_sequence.h"
@@ -98,6 +102,70 @@ static void draw_seq_text(Sequence *seq, float x1, float x2, float y1, float y2)
 static void draw_shadedstrip(Sequence *seq, char *col, float x1, float y1, float x2, float y2);
 static void draw_seq_strip(struct Sequence *seq, struct ScrArea *sa, struct SpaceSeq *sseq, int outline_tint, float pixelx);
 
+
+static void seq_panel_gpencil(short cntrl)	// SEQ_HANDLER_GREASEPENCIL
+{
+	uiBlock *block;
+	SpaceSeq *sseq;
+	
+	sseq= curarea->spacedata.first;
+
+	block= uiNewBlock(&curarea->uiblocks, "seq_panel_gpencil", UI_EMBOSS, UI_HELV, curarea->win);
+	uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE  | cntrl);
+	uiSetPanelHandler(SEQ_HANDLER_GREASEPENCIL);  // for close and esc
+	if (uiNewPanel(curarea, block, "Grease Pencil", "SpaceSeq", 100, 30, 318, 204)==0) return;
+	
+	/* only draw settings if right mode */
+	if (sseq->mainb == 0)
+		return;
+	
+	/* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
+	if (sseq->flag & SEQ_DRAW_GPENCIL) {
+		if (sseq->gpd == NULL)
+			gpencil_data_setactive(curarea, gpencil_data_addnew());
+	}
+	
+	if (sseq->flag & SEQ_DRAW_GPENCIL) {
+		bGPdata *gpd= sseq->gpd;
+		short newheight;
+		
+		/* this is a variable height panel, newpanel doesnt force new size on existing panels */
+		/* so first we make it default height */
+		uiNewPanelHeight(block, 204);
+		
+		/* draw button for showing gpencil settings and drawings */
+		uiDefButBitI(block, TOG, SEQ_DRAW_GPENCIL, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &sseq->flag, 0, 0, 0, 0, "Display freehand annotations overlay over this Sequencer View");
+		
+		/* extend the panel if the contents won't fit */
+		newheight= draw_gpencil_panel(block, gpd, curarea); 
+		uiNewPanelHeight(block, newheight);
+	}
+	else {
+		uiDefButBitI(block, TOG, SEQ_DRAW_GPENCIL, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &sseq->flag, 0, 0, 0, 0, "Display freehand annotations overlay over this Sequencer View");
+		uiDefBut(block, LABEL, 1, " ",	160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
+	}
+}
+
+static void seq_blockhandlers(ScrArea *sa)
+{
+	SpaceSeq *sseq= sa->spacedata.first;
+	short a;
+
+	/* warning; blocks need to be freed each time, handlers dont remove (for ipo moved to drawipospace) */
+	uiFreeBlocksWin(&sa->uiblocks, sa->win);
+
+	for(a=0; a<SPACE_MAXHANDLER; a+=2) {
+		switch(sseq->blockhandler[a]) {
+			case SEQ_HANDLER_GREASEPENCIL:
+				seq_panel_gpencil(sseq->blockhandler[a+1]);
+				break;
+		}
+	}
+	uiDrawBlocksPanels(sa, 0);
+
+}
+
+
 static void draw_cfra_seq(void)
 {
 	glColor3ub(0x30, 0x90, 0x50);
@@ -907,6 +975,17 @@ static void draw_image_seq(ScrArea *sa)
 	if (free_ibuf) {
 		IMB_freeImBuf(ibuf);
 	} 
+	
+	/* draw grease-pencil (screen aligned) */
+	if (sseq->flag & SEQ_DRAW_GPENCIL)
+		draw_gpencil_2dview(sa, 0);
+	
+	/* ortho at pixel level sa */
+	myortho2(-0.375, sa->winx-0.375, -0.375, sa->winy-0.375);
+	
+	/* it is important to end a view in a transform compatible with buttons */
+	bwin_scalematrix(sa->win, sseq->blockscale, sseq->blockscale, sseq->blockscale);
+	seq_blockhandlers(sa);
 
 	sa->win_swap= WIN_BACK_OK;
 }
@@ -1023,24 +1102,6 @@ void seq_viewmove(SpaceSeq *sseq)
 	window_set_cursor(win, oldcursor);
 }
 
-
-
-static void seq_blockhandlers(ScrArea *sa)
-{
-	SpaceSeq *sseq= sa->spacedata.first;
-	short a;
-
-	/* warning; blocks need to be freed each time, handlers dont remove (for ipo moved to drawipospace) */
-	uiFreeBlocksWin(&sa->uiblocks, sa->win);
-
-	for(a=0; a<SPACE_MAXHANDLER; a+=2) {
-		/* clear action value for event */
-		sseq->blockhandler[a+1]= 0;
-	}
-	uiDrawBlocksPanels(sa, 0);
-
-}
-
 void drawprefetchseqspace(ScrArea *sa, void *spacedata)
 {
 	SpaceSeq *sseq= sa->spacedata.first;
diff --git a/source/blender/src/drawview.c b/source/blender/src/drawview.c
index f595a101f63..14434504e7a 100644
--- a/source/blender/src/drawview.c
+++ b/source/blender/src/drawview.c
@@ -61,6 +61,7 @@
 #include "DNA_constraint_types.h"
 #include "DNA_curve_types.h"
 #include "DNA_group_types.h"
+#include "DNA_gpencil_types.h"
 #include "DNA_image_types.h"
 #include "DNA_key_types.h"
 #include "DNA_lattice_types.h"
@@ -111,6 +112,7 @@
 
 #include "BIF_butspace.h"
 #include "BIF_drawimage.h"
+#include "BIF_drawgpencil.h"
 #include "BIF_editgroup.h"
 #include "BIF_editarmature.h"
 #include "BIF_editmesh.h"
@@ -137,6 +139,7 @@
 #include "BDR_editobject.h"
 #include "BDR_vpaint.h"
 #include "BDR_sculptmode.h"
+#include "BDR_gpencil.h"
 
 #include "BSE_drawview.h"
 #include "BSE_filesel.h"
@@ -2498,7 +2501,7 @@ static void view3d_panel_background(short cntrl)	// VIEW3D_HANDLER_BACKGROUND
 	uiSetPanelHandler(VIEW3D_HANDLER_BACKGROUND);  // for close and esc
 	if(uiNewPanel(curarea, block, "Background Image", "View3d", 340, 10, 318, 204)==0) return;
 
-	if(G.f & G_VERTEXPAINT || G.f & G_WEIGHTPAINT || G.f & G_TEXTUREPAINT) {
+	if(G.f & G_VERTEXPAINT || G.f & G_WEIGHTPAINT || G.f & G_TEXTUREPAINT || G.f & G_GREASEPENCIL) {
 		uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);	// force old style frontbuffer draw
 	}
 	
@@ -2546,7 +2549,7 @@ static void view3d_panel_properties(short cntrl)	// VIEW3D_HANDLER_SETTINGS
 	/* to force height */
 	uiNewPanelHeight(block, 264);
 
-	if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
+	if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT|G_GREASEPENCIL)) {
 		uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);	// force old style frontbuffer draw
 	}
 
@@ -2620,6 +2623,49 @@ static void view3d_panel_preview(ScrArea *sa, short cntrl)	// VIEW3D_HANDLER_PRE
 	}
 }
 
+static void view3d_panel_gpencil(short cntrl)	// VIEW3D_HANDLER_GREASEPENCIL
+{
+	uiBlock *block;
+	View3D *vd;
+	
+	vd= G.vd;
+
+	block= uiNewBlock(&curarea->uiblocks, "view3d_panel_gpencil", UI_EMBOSS, UI_HELV, curarea->win);
+	uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE  | cntrl);
+	uiSetPanelHandler(VIEW3D_HANDLER_GREASEPENCIL);  // for close and esc
+	if (uiNewPanel(curarea, block, "Grease Pencil", "View3d", 100, 30, 318, 204)==0) return;
+
+	if (G.f & (G_VERTEXPAINT|G_WEIGHTPAINT|G_TEXTUREPAINT|G_GREASEPENCIL)) {
+		uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);	// force old style frontbuffer draw
+	}
+	
+	/* allocate memory for gpd if drawing enabled (this must be done first or else we crash) */
+	if (vd->flag2 & V3D_DISPGP) {
+		if (vd->gpd == NULL)
+			gpencil_data_setactive(curarea, gpencil_data_addnew());
+	}
+	
+	if (vd->flag2 & V3D_DISPGP) {
+		bGPdata *gpd= vd->gpd;
+		short newheight;
+		
+		/* this is a variable height panel, newpanel doesnt force new size on existing panels */
+		/* so first we make it default height */
+		uiNewPanelHeight(block, 204);
+		
+		/* draw button for showing gpencil settings and drawings */
+		uiDefButBitS(block, TOG, V3D_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &vd->flag2, 0, 0, 0, 0, "Display freehand annotations overlay over this 3D View");
+		
+		/* extend the panel if the contents won't fit */
+		newheight= draw_gpencil_panel(block, gpd, curarea); 
+		uiNewPanelHeight(block, newheight);
+	}
+	else {
+		uiDefButBitS(block, TOG, V3D_DISPGP, B_REDR, "Use Grease Pencil", 10, 225, 150, 20, &vd->flag2, 0, 0, 0, 0, "Display freehand annotations overlay over this 3D View");
+		uiDefBut(block, LABEL, 1, " ",	160, 180, 150, 20, NULL, 0.0, 0.0, 0, 0, "");
+	}
+}
+
 
 static void view3d_blockhandlers(ScrArea *sa)
 {
@@ -2634,9 +2680,7 @@ static void view3d_blockhandlers(ScrArea *sa)
 	glDisable(GL_DEPTH_TEST); 
 	
 	for(a=0; a<SPACE_MAXHANDLER; a+=2) {
-	
 		switch(v3d->blockhandler[a]) {
-
 		case VIEW3D_HANDLER_PROPERTIES:
 			view3d_panel_properties(v3d->blockhandler[a+1]);
 			break;
@@ -2651,7 +2695,10 @@ static void view3d_blockhandlers(ScrArea *sa)
 			break;			
 		case VIEW3D_HANDLER_TRANSFORM:
 			view3d_panel_transform_spaces(v3d->blockhandler[a+1]);
- 			break;			
+ 			break;
+		case VIEW3D_HANDLER_GREASEPENCIL:
+			view3d_panel_gpencil(v3d->blockhandler[a+1]);
+			break;
 		}
 		/* clear action value for event */
 		v3d->blockhandler[a+1]= 0;
@@ -3169,7 +3216,11 @@ void drawview3dspace(ScrArea *sa, void *spacedata)
 		v3d->zbuf= FALSE;
 		glDisable(GL_DEPTH_TEST);
 	}
-
+	
+	/* draw grease-pencil stuff */
+	if (v3d->flag2 & V3D_DISPGP)
+		draw_gpencil_3dview(sa, 1);
+	
 	persp(PERSP_WIN);  // set ortho
 
 	/* Draw Sculpt Mode brush */
@@ -3211,6 +3262,11 @@ void drawview3dspace(ScrArea *sa, void *spacedata)
 
 	if(v3d->persp>1) drawviewborder();
 	if(v3d->flag2 & V3D_FLYMODE) drawviewborder_flymode();
+	
+	/* draw grease-pencil stuff */
+	if (v3d->flag2 & V3D_DISPGP)
+		draw_gpencil_3dview(sa, 0);
+	
 	if(!(G.f & G_PLAYANIM)) drawcursor(v3d);
 	if(U.uiflag & USER_SHOW_ROTVIEWICON)
 		draw_view_axis();
@@ -3311,16 +3367,15 @@ void drawview3d_render(struct View3D *v3d, int winx, int winy, float winmat[][4]
 
 	/* first draw set */
 	if(G.scene->set) {
-	
 		for(SETLOOPER(G.scene->set, base)) {
 			if(v3d->lay & base->lay) {
 				if ELEM3(base->object->type, OB_LAMP, OB_CAMERA, OB_LATTICE);
 				else {
 					where_is_object(base->object);
-	
+					
 					BIF_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f);
 					draw_object(base, DRAW_CONSTCOLOR|DRAW_SCENESET);
-	
+					
 					if(base->object->transflag & OB_DUPLI) {
 						draw_dupli_objects(v3d, base);
 					}
@@ -3377,6 +3432,13 @@ void drawview3d_render(struct View3D *v3d, int winx, int winy, float winmat[][4]
 		glDisable(GL_DEPTH_TEST);
 	}
 	
+	if(v3d->gpd) {
+		/* draw grease-pencil overlays 
+		 * WARNING: view matrices are altered here!
+		 */
+		draw_gpencil_oglrender(v3d, winx, winy);
+	}
+	
 	G.f &= ~G_SIMULATION;
 
 	glFlush();
diff --git a/source/blender/src/editaction.c b/source/blender/src/editaction.c
index f93a1526e3c..3251cb33b53 100644
--- a/source/blender/src/editaction.c
+++ b/source/blender/src/editaction.c
@@ -52,6 +52,7 @@
 #include "DNA_mesh_types.h"
 #include "DNA_nla_types.h"
 #include "DNA_lattice_types.h"
+#include "DNA_gpencil_types.h"
 
 #include "BKE_action.h"
 #include "BKE_armature.h"
@@ -90,6 +91,7 @@
 
 #include "BDR_drawaction.h"
 #include "BDR_editobject.h"
+#include "BDR_gpencil.h"
 
 #include "mydevice.h"
 #include "blendef.h"
@@ -296,6 +298,16 @@ bActListElem *make_new_actlistelem (void *data, short datatype, void *owner, sho
 				ale->datatype= ALE_IPO;
 			}
 				break;
+			case ACTTYPE_GPLAYER:
+			{
+				bGPDlayer *gpl= (bGPDlayer *)data;
+				
+				ale->flag= gpl->flag;
+				
+				ale->key_data= NULL;
+				ale->datatype= ALE_GPFRAME;
+			}
+				break;
 		}
 	}
 	
@@ -505,6 +517,29 @@ static void actdata_filter_shapekey (ListBase *act_data, Key *key, int filter_mo
 	}
 }
  
+static void actdata_filter_gpencil (ListBase *act_data, bGPdata *gpd, int filter_mode)
+{
+	bActListElem *ale;
+	bGPDlayer *gpl;
+	
+	/* check if filtering types are appropriate */
+	if ( !(filter_mode & (ACTFILTER_IPOKEYS|ACTFILTER_ONLYICU|ACTFILTER_ACTGROUPED)) ) 
+	{
+		/* loop over layers as the conditions are acceptable */
+		for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+			/* only if selected */
+			if (!(filter_mode & ACTFILTER_SEL) || SEL_GPL(gpl)) {
+				/* only if editable */
+				if (!(filter_mode & ACTFILTER_FOREDIT) || EDITABLE_GPL(gpl)) {
+					/* add to list */
+					ale= make_new_actlistelem(gpl, ACTTYPE_GPLAYER, NULL, ACTTYPE_NONE);
+					if (ale) BLI_addtail(act_data, ale);
+				}
+			}
+		}
+	}
+}
+ 
 /* This function filters the active data source to leave only the desired
  * data types. 'Public' api call.
  * 	*act_data: is a pointer to a ListBase, to which the filtered action data 
@@ -525,6 +560,9 @@ void actdata_filter (ListBase *act_data, int filter_mode, void *data, short data
 			case ACTCONT_SHAPEKEY:
 				actdata_filter_shapekey(act_data, data, filter_mode);
 				break;
+			case ACTCONT_GPENCIL:
+				actdata_filter_gpencil(act_data, data, filter_mode);
+				break;
 		}
 			
 		/* remove any weedy entries */
@@ -743,6 +781,10 @@ static void *get_nearest_action_key (float *selx, short *sel, short *ret_type, b
 				bActionGroup *agrp= (bActionGroup *)ale->data;
 				agroup_to_keylist(agrp, &act_keys, NULL, NULL);
 			}
+			else if (ale->type == ACTTYPE_GPLAYER) {
+				bGPDlayer *gpl= (bGPDlayer *)ale->data;
+				gpl_to_keylist(gpl, &act_keys, NULL, NULL);
+			}
 			
 			/* loop through keyframes, finding one that was clicked on */
 			for (ak= act_keys.first; ak; ak= ak->next) {
@@ -766,6 +808,10 @@ static void *get_nearest_action_key (float *selx, short *sel, short *ret_type, b
 				data = ale->key_data;
 				*ret_type= ACTTYPE_ICU;
 			}
+			else if (datatype == ACTCONT_GPENCIL) {
+				data = ale->data;
+				*ret_type= ACTTYPE_GPLAYER;
+			}
 			
 			/* cleanup tempolary lists */
 			BLI_freelistN(&act_keys);
@@ -795,17 +841,43 @@ void *get_action_context (short *datatype)
 	act = (G.saction)? G.saction->action: NULL;
 	key = get_action_mesh_key();
 	
-	if (act) {
-		*datatype= ACTCONT_ACTION;
-		return act;
-	}
-	else if (key) {
-		*datatype= ACTCONT_SHAPEKEY;
-		return key;
+	/* check mode selector */
+	if (G.saction) {
+		switch (G.saction->mode) {
+			case SACTCONT_ACTION: 
+				*datatype= ACTCONT_ACTION;
+				return act;
+				
+			case SACTCONT_SHAPEKEY:
+				*datatype= ACTCONT_SHAPEKEY;
+				return key;
+				
+			case SACTCONT_GPENCIL:
+				*datatype= ACTCONT_GPENCIL;
+				if (G.saction->pin)
+					return G.saction->gpd;
+				else
+					return gpencil_data_getetime(G.curscreen);
+			
+			default: /* includes SACTCONT_DOPESHEET for now */
+				*datatype= ACTCONT_NONE;
+				return NULL;
+		}
 	}
 	else {
-		*datatype= ACTCONT_NONE;
-		return NULL;
+		/* resort to guessing based on what is available */
+		if (act) {
+			*datatype= ACTCONT_ACTION;
+			return act;
+		}
+		else if (key) {
+			*datatype= ACTCONT_SHAPEKEY;
+			return key;
+		}
+		else {
+			*datatype= ACTCONT_NONE;
+			return NULL;
+		}
 	}
 }
 
@@ -1114,6 +1186,38 @@ void action_groups_ungroup (void)
 	allqueue(REDRAWACTION, 0);
 }
 
+/* Copy colors from a specified theme's color set to an Action/Bone Group */
+void actionbone_group_copycolors (bActionGroup *grp, short init_new)
+{
+	/* error checking */
+	if (grp == NULL)
+		return;
+	
+	/* only do color copying if using a custom color */
+	if (grp->customCol) {
+		if (grp->customCol > 0) {
+			/* copy theme colors on-to group's custom color in case user tries to edit color */
+			bTheme *btheme= U.themes.first;
+			ThemeWireColor *col_set= &btheme->tarm[(grp->customCol - 1)];
+			
+			memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
+		}
+		else if (init_new) {
+			/* init custom colors with a generic multi-color rgb set, if not initialised already (and allowed to do so) */
+			if (grp->cs.solid[0] == 0) {
+				/* define for setting colors in theme below */
+				#define SETCOL(col, r, g, b, a)  col[0]=r; col[1]=g; col[2]= b; col[3]= a;
+				
+				SETCOL(grp->cs.solid, 0xff, 0x00, 0x00, 255);
+				SETCOL(grp->cs.select, 0x81, 0xe6, 0x14, 255);
+				SETCOL(grp->cs.active, 0x18, 0xb6, 0xe0, 255);
+				
+				#undef SETCOL
+			}
+		}
+	}
+}
+
 /* This function is used when inserting keyframes for pose-channels. It assigns the
  * action-channel with the nominated name to a group with the same name as that of 
  * the pose-channel with the nominated name.
@@ -1160,34 +1264,9 @@ void verify_pchan2achan_grouping (bAction *act, bPose *pose, char name[])
 			/* copy name */
 			sprintf(grp->name, agrp->name);
 			
-			/* deal with group-color copying */
-			if (agrp->customCol) {
-				if (agrp->customCol > 0) {
-					/* copy theme colors on-to group's custom color in case user tries to edit color */
-					bTheme *btheme= U.themes.first;
-					ThemeWireColor *col_set= &btheme->tarm[(agrp->customCol - 1)];
-					
-					memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
-				}
-				else {
-					/* init custom colors with a generic multi-color rgb set, if not initialised already */
-					if (agrp->cs.solid[0] == 0) {
-						/* define for setting colors in theme below */
-						#define SETCOL(col, r, g, b, a)  col[0]=r; col[1]=g; col[2]= b; col[3]= a;
-						
-						SETCOL(grp->cs.solid, 0xff, 0x00, 0x00, 255);
-						SETCOL(grp->cs.select, 0x81, 0xe6, 0x14, 255);
-						SETCOL(grp->cs.active, 0x18, 0xb6, 0xe0, 255);
-						
-						#undef SETCOL
-					}
-					else {
-						/* just copy color set specified */
-						memcpy(&grp->cs, &agrp->cs, sizeof(ThemeWireColor));
-					}
-				}
-			}
-			grp->customCol= agrp->customCol;
+			/* deal with group-color copying (grp is destination, agrp is source) */
+			memcpy(grp, agrp, sizeof(bActionGroup));
+			actionbone_group_copycolors(grp, 1);
 			
 			BLI_addtail(&act->groups, grp);
 		}
@@ -1300,12 +1379,18 @@ void duplicate_action_keys (void)
 	if (data == NULL) return;
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* loop through filtered data and duplicate selected keys */
 	for (ale= act_data.first; ale; ale= ale->next) {
-		duplicate_ipo_keys((Ipo *)ale->key_data);
+		if (ale->type == ACTTYPE_GPLAYER)
+			duplicate_gplayer_frames(ale->data);
+		else
+			duplicate_ipo_keys((Ipo *)ale->key_data);
 	}
 	
 	/* free filtered list */
@@ -1391,7 +1476,10 @@ void snap_action_keys(short mode)
 	}
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* snap to frame */
@@ -1401,6 +1489,8 @@ void snap_action_keys(short mode)
 			snap_ipo_keys(ale->key_data, mode);
 			actstrip_map_ipo_keys(OBACT, ale->key_data, 1, 1);
 		}
+		else if (ale->type == ACTTYPE_GPLAYER)
+			snap_gplayer_frames(ale->data, mode);
 		else 
 			snap_ipo_keys(ale->key_data, mode);
 	}
@@ -1414,6 +1504,7 @@ void snap_action_keys(short mode)
 	allqueue(REDRAWACTION, 0);
 	allqueue(REDRAWIPO, 0);
 	allqueue(REDRAWNLA, 0);
+	allqueue(REDRAWVIEW3D, 0);
 }
 
 /* this function is responsible for snapping keyframes to frame-times */
@@ -1449,7 +1540,10 @@ void mirror_action_keys(short mode)
 	}
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* mirror */
@@ -1459,6 +1553,8 @@ void mirror_action_keys(short mode)
 			mirror_ipo_keys(ale->key_data, mode);
 			actstrip_map_ipo_keys(OBACT, ale->key_data, 1, 1);
 		}
+		else if (ale->type == ACTTYPE_GPLAYER)
+			mirror_gplayer_frames(ale->data, mode);
 		else 
 			mirror_ipo_keys(ale->key_data, mode);
 	}
@@ -1543,6 +1639,10 @@ void insertkey_action(void)
 			}
 		}
 	}
+	else {
+		/* this tool is not supported in this mode */
+		return;
+	}
 	
 	BIF_undo_push("Insert Key");
 	allspace(REMAKEIPO, 0);
@@ -1566,12 +1666,18 @@ void delete_action_keys (void)
 	if (data == NULL) return;
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* loop through filtered data and delete selected keys */
 	for (ale= act_data.first; ale; ale= ale->next) {
-		delete_ipo_keys((Ipo *)ale->key_data);
+		if (ale->type == ACTTYPE_GPLAYER)
+			delete_gplayer_frames((bGPDlayer *)ale->data);
+		else
+			delete_ipo_keys((Ipo *)ale->key_data);
 	}
 	
 	/* free filtered list */
@@ -1692,6 +1798,7 @@ void clean_action (void)
 				0.0000001f, 1.0, 0.001, 0.1,
 				"Clean Threshold");
 	if (!ok) return;
+	if (datatype == ACTCONT_GPENCIL) return;
 	
 	/* filter data */
 	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_SEL | ACTFILTER_ONLYICU);
@@ -1730,6 +1837,7 @@ void sample_action_keys (void)
 	/* sanity checks */
 	data= get_action_context(&datatype);
 	if (data == NULL) return;
+	if (datatype == ACTCONT_GPENCIL) return;
 	
 	/* filter data */
 	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_ONLYICU);
@@ -2089,6 +2197,7 @@ void action_set_ipo_flags (short mode, short event)
 	/* determine what type of data we are operating on */
 	data = get_action_context(&datatype);
 	if (data == NULL) return;
+	if (datatype == ACTCONT_GPENCIL) return;
 	
 	/* determine which set of processing we are doing */
 	switch (mode) {
@@ -2187,6 +2296,7 @@ void sethandles_action_keys (int code)
 	/* determine what type of data we are operating on */
 	data = get_action_context(&datatype);
 	if (data == NULL) return;
+	if (datatype == ACTCONT_GPENCIL) return;
 	
 	/* filter data */
 	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
@@ -2225,11 +2335,12 @@ static void numbuts_action ()
 	bConstraintChannel *conchan= NULL;
 	IpoCurve *icu= NULL;
 	KeyBlock *kb= NULL;
+	bGPDlayer *gpl= NULL;
 	
 	short mval[2];
 	
 	int but=0;
-    char str[64];
+    char str[128];
 	short expand, protect, mute;
 	float slidermin, slidermax;
 	
@@ -2338,6 +2449,18 @@ static void numbuts_action ()
 		add_numbut(but++, TOG|SHO, "Expanded", 0, 24, &expand, "Action Group is Expanded");
 		add_numbut(but++, TOG|SHO, "Protected", 0, 24, &protect, "Group is Protected");
 	}
+	else if (chantype == ACTTYPE_GPLAYER) {
+		/* Grease-Pencil Layer */
+		gpl= (bGPDlayer *)act_channel;
+		
+		strcpy(str, gpl->info);
+		protect= (gpl->flag & GP_LAYER_LOCKED);
+		mute = (gpl->flag & GP_LAYER_HIDE);
+		
+		add_numbut(but++, TEX, "GP-Layer: ", 0, 128, str, "Name of Grease Pencil Layer");
+		add_numbut(but++, TOG|SHO, "Hide", 0, 24, &mute, "Grease Pencil Layer is Visible");
+		add_numbut(but++, TOG|SHO, "Protected", 0, 24, &protect, "Grease Pencil Layer is Protected");
+	}
 	else {
 		/* nothing under-cursor */
 		return;
@@ -2386,6 +2509,16 @@ static void numbuts_action ()
 			if (protect) agrp->flag |= AGRP_PROTECTED;
 			else agrp->flag &= ~AGRP_PROTECTED;
 		}
+		else if (gpl) {
+			strcpy(gpl->info, str);
+			BLI_uniquename(&( ((bGPdata *)data)->layers ), gpl, "GP_Layer", offsetof(bGPDlayer, info), 128);
+			
+			if (mute) gpl->flag |= GP_LAYER_HIDE;
+			else gpl->flag &= ~GP_LAYER_HIDE;;
+			
+			if (protect) gpl->flag |= GP_LAYER_LOCKED;
+			else gpl->flag &= ~GP_LAYER_LOCKED;
+		}
 		
         allqueue(REDRAWACTION, 0);
 		allspace(REMAKEIPO, 0);
@@ -2517,6 +2650,31 @@ void setflag_action_channels (short mode)
 				}
 			}
 				break;
+			case ACTTYPE_GPLAYER:
+			{
+				bGPDlayer *gpl= (bGPDlayer *)ale->data;
+				
+				/* 'protect' and 'mute' */
+				if (val == 2) {
+					/* mute */
+					if (mode == 2)
+						gpl->flag &= ~GP_LAYER_HIDE;
+					else if (mode == 1)
+						gpl->flag |= GP_LAYER_HIDE;
+					else
+						gpl->flag ^= GP_LAYER_HIDE;
+				}
+				else if (val == 1) {
+					/* protected */
+					if (mode == 2)
+						gpl->flag &= ~GP_LAYER_LOCKED;
+					else if (mode == 1)
+						gpl->flag |= GP_LAYER_LOCKED;
+					else
+						gpl->flag ^= GP_LAYER_LOCKED;
+				}
+			}
+				break;
 		}
 	}
 	BLI_freelistN(&act_data);
@@ -2557,7 +2715,7 @@ static void select_action_group (bAction *act, bActionGroup *agrp, int selectmod
 	set_active_actiongroup(act, agrp, select);
 }
 
-static void hilight_channel(bAction *act, bActionChannel *achan, short select)
+static void hilight_channel (bAction *act, bActionChannel *achan, short select)
 {
 	bActionChannel *curchan;
 
@@ -2630,7 +2788,7 @@ void select_actionchannel_by_name (bAction *act, char *name, int select)
 
 /* exported for outliner (ton) */
 /* apparently within active object context */
-int select_channel(bAction *act, bActionChannel *achan, int selectmode) 
+int select_channel (bAction *act, bActionChannel *achan, int selectmode) 
 {
 	/* Select the channel based on the selection mode */
 	int flag;
@@ -2654,9 +2812,9 @@ int select_channel(bAction *act, bActionChannel *achan, int selectmode)
 	return flag;
 }
 
-static int select_constraint_channel(bAction *act, 
-                                     bConstraintChannel *conchan, 
-                                     int selectmode) 
+static int select_constraint_channel (bAction *act, 
+                                      bConstraintChannel *conchan, 
+                                      int selectmode) 
 {
 	/* Select the constraint channel based on the selection mode */
 	int flag;
@@ -2677,7 +2835,7 @@ static int select_constraint_channel(bAction *act,
 	return flag;
 }
 
-int select_icu_channel(bAction *act, IpoCurve *icu, int selectmode) 
+int select_icu_channel (bAction *act, IpoCurve *icu, int selectmode) 
 {
 	/* Select the channel based on the selection mode */
 	int flag;
@@ -2697,6 +2855,51 @@ int select_icu_channel(bAction *act, IpoCurve *icu, int selectmode)
 	return flag;
 }
 
+int select_gplayer_channel (bGPdata *gpd, bGPDlayer *gpl, int selectmode) 
+{
+	/* Select the channel based on the selection mode */
+	int flag;
+
+	switch (selectmode) {
+	case SELECT_ADD:
+		gpl->flag |= GP_LAYER_SELECT;
+		break;
+	case SELECT_SUBTRACT:
+		gpl->flag &= ~GP_LAYER_SELECT;
+		break;
+	case SELECT_INVERT:
+		gpl->flag ^= GP_LAYER_SELECT;
+		break;
+	}
+	flag = (gpl->flag & GP_LAYER_SELECT) ? 1 : 0;
+
+	gpencil_layer_setactive(gpd, gpl);
+
+	return flag;
+}
+
+
+/* select only the active action-group's action channels */
+void select_action_group_channels (bAction *act, bActionGroup *agrp)
+{
+	bActionChannel *achan;
+	
+	/* error checking */
+	if (ELEM(NULL, act, agrp))
+		return;
+	
+	/* deselect all other channels */
+	deselect_actionchannels(act, 0);
+	
+	/* only select channels in group */
+	for (achan= agrp->channels.first; achan && achan->grp==agrp; achan= achan->next) {
+		select_channel(act, achan, SELECT_ADD);
+		
+		/* messy... set active bone */
+		select_poseelement_by_name(achan->name, 1);
+	}
+}
+
 /* ----------------------------------------- */
 
 /* De-selects or inverts the selection of Channels in a given Action 
@@ -2819,6 +3022,8 @@ void deselect_action_channels (short mode)
 	/* based on type */
 	if (datatype == ACTCONT_ACTION)
 		deselect_actionchannels(data, mode);
+	else if (datatype == ACTCONT_GPENCIL)
+		deselect_gpencil_layers(data, mode);
 	// should shapekey channels be allowed to do this? 
 }
 
@@ -2834,24 +3039,40 @@ void deselect_action_keys (short test, short sel)
 	/* determine what type of data we are operating on */
 	data = get_action_context(&datatype);
 	if (data == NULL) return;
-		
+	
+	/* determine type-based settings */
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
+	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* See if we should be selecting or deselecting */
 	if (test) {
 		for (ale= act_data.first; ale; ale= ale->next) {
-			if (is_ipo_key_selected(ale->key_data)) {
-				sel= 0;
-				break;
+			if (ale->type == ACTTYPE_GPLAYER) {
+				if (is_gplayer_frame_selected(ale->data)) {
+					sel= 0;
+					break;
+				}
+			}
+			else {
+				if (is_ipo_key_selected(ale->key_data)) {
+					sel= 0;
+					break;
+				}
 			}
 		}
 	}
 		
 	/* Now set the flags */
 	for (ale= act_data.first; ale; ale= ale->next) {
-		set_ipo_key_selection(ale->key_data, sel);
+		if (ale->type == ACTTYPE_GPLAYER)
+			set_gplayer_frame_selection(ale->data, sel);
+		else
+			set_ipo_key_selection(ale->key_data, sel);
 	}
 	
 	/* Cleanup */
@@ -2917,6 +3138,12 @@ void selectall_action_keys (short mval[], short mode, short select_mode)
 					select_icu_bezier_keys(icu, select_mode);
 				}
 					break;
+				case ACTTYPE_GPLAYER:
+				{
+					bGPDlayer *gpl= (bGPDlayer *)act_channel;
+					select_gpencil_frames(gpl, select_mode);
+				}
+					break;
 			}
 		}
 			break;
@@ -2942,12 +3169,16 @@ void selectall_action_keys (short mval[], short mode, short select_mode)
 			rectf.xmax = rectf.xmax + 0.5;
 			
 			/* filter data */
-			filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
+			if (datatype == ACTCONT_GPENCIL)
+				filter= (ACTFILTER_VISIBLE);
+			else
+				filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
 			actdata_filter(&act_data, filter, data, datatype);
 				
 			/* Now set the flags */
-			for (ale= act_data.first; ale; ale= ale->next)
+			for (ale= act_data.first; ale; ale= ale->next) {
 				borderselect_ipo_key(ale->key_data, rectf.xmin, rectf.xmax, select_mode);
+			}
 			
 			/* Cleanup */
 			BLI_freelistN(&act_data);
@@ -3029,19 +3260,23 @@ void selectkeys_leftright (short leftright, short select_mode)
 	}
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 		
 	/* select keys on the side where most data occurs */
 	for (ale= act_data.first; ale; ale= ale->next) {
-		if(NLA_ACTION_SCALED && datatype==ACTCONT_ACTION) {
+		if (NLA_ACTION_SCALED && datatype==ACTCONT_ACTION) {
 			actstrip_map_ipo_keys(OBACT, ale->key_data, 0, 1);
 			borderselect_ipo_key(ale->key_data, min, max, SELECT_ADD);
 			actstrip_map_ipo_keys(OBACT, ale->key_data, 1, 1);
 		}
-		else {
+		else if (ale->type == ACTTYPE_GPLAYER)
+			borderselect_gplayer_frames(ale->data, min, max, SELECT_ADD);
+		else
 			borderselect_ipo_key(ale->key_data, min, max, SELECT_ADD);
-		}
 	}
 	
 	/* Cleanup */
@@ -3079,7 +3314,10 @@ void nextprev_action_keyframe (short dir)
 		return;
 	
 	/* get list of keyframes that can be used (in global-time) */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	for (ale= act_data.first; ale; ale= ale->next) {
@@ -3088,6 +3326,8 @@ void nextprev_action_keyframe (short dir)
 			make_cfra_list(ale->key_data, &elems);
 			actstrip_map_ipo_keys(OBACT, ale->key_data, 1, 1);
 		}
+		else if (ale->type == ACTTYPE_GPLAYER)
+			gplayer_make_cfra_list(ale->key_data, &elems, 0);
 		else 
 			make_cfra_list(ale->key_data, &elems);
 	}
@@ -3170,11 +3410,20 @@ void column_select_action_keys (int mode)
 	/* build list of columns */
 	switch (mode) {
 		case 1: /* list of selected keys */
-			filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
-			actdata_filter(&act_data, filter, data, datatype);
-			
-			for (ale= act_data.first; ale; ale= ale->next)
-				make_sel_cfra_list(ale->key_data, &elems);
+			if (datatype == ACTCONT_GPENCIL) {
+				filter= (ACTFILTER_VISIBLE);
+				actdata_filter(&act_data, filter, data, datatype);
+				
+				for (ale= act_data.first; ale; ale= ale->next)
+					gplayer_make_cfra_list(ale->data, &elems, 1);
+			}
+			else {
+				filter= (ACTFILTER_VISIBLE | ACTFILTER_IPOKEYS);
+				actdata_filter(&act_data, filter, data, datatype);
+				
+				for (ale= act_data.first; ale; ale= ale->next)
+					make_sel_cfra_list(ale->key_data, &elems);
+			}
 			
 			BLI_freelistN(&act_data);
 			break;
@@ -3202,19 +3451,34 @@ void column_select_action_keys (int mode)
 	/* loop through all of the keys and select additional keyframes
 	 * based on the keys found to be selected above
 	 */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_ONLYICU);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_ONLYICU);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	for (ale= act_data.first; ale; ale= ale->next) {
 		for (ce= elems.first; ce; ce= ce->next) {
-			for (icu= ale->key_data; icu; icu= icu->next) {
-				BezTriple *bezt;
-				int verts = 0;
+			/* select elements with frame number matching cfraelem */
+			if (ale->type == ACTTYPE_GPLAYER) {
+				bGPDlayer *gpl= (bGPDlayer *)ale->data;
+				bGPDframe *gpf;
 				
-				for (bezt=icu->bezt; verts<icu->totvert; bezt++, verts++) {
-					if (bezt) {
-						if( (int)(ce->cfra) == (int)(bezt->vec[1][0]) )
-							bezt->f2 |= 1;
+				for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+					if ( (int)ce->cfra == gpf->framenum ) 
+						gpf->flag |= GP_FRAME_SELECT;
+				}
+			}
+			else {
+				for (icu= ale->key_data; icu; icu= icu->next) {
+					BezTriple *bezt;
+					int verts = 0;
+					
+					for (bezt=icu->bezt; verts<icu->totvert; bezt++, verts++) {
+						if (bezt) {
+							if( (int)(ce->cfra) == (int)(bezt->vec[1][0]) )
+								bezt->f2 |= 1;
+						}
 					}
 				}
 			}
@@ -3243,7 +3507,7 @@ void borderselect_actionchannels (void)
 	/* determine what type of data we are operating on */
 	data = get_action_context(&datatype);
 	if (data == NULL) return;
-	if (datatype != ACTCONT_ACTION) return;
+	if (ELEM(datatype, ACTCONT_ACTION, ACTCONT_GPENCIL)==0) return;
 	
 	/* draw and handle the borderselect stuff (ui) and get the select rect */
 	if ( (val = get_border(&rect, 3)) ) {
@@ -3315,6 +3579,16 @@ void borderselect_actionchannels (void)
 							icu->flag &= ~IPO_SELECT;
 					}
 						break;
+					case ACTTYPE_GPLAYER: /* grease-pencil layer */
+					{
+						bGPDlayer *gpl = (bGPDlayer *)ale->data;
+						
+						if (selectmode == SELECT_ADD)
+							gpl->flag |= GP_LAYER_SELECT;
+						else
+							gpl->flag &= ~GP_LAYER_SELECT;
+					}
+						break;
 				}
 				
 				/* select action-channel 'owner' */
@@ -3431,6 +3705,9 @@ void borderselect_action (void)
 							borderselect_ipo_key(conchan->ipo, rectf.xmin, rectf.xmax, selectmode);
 					}
 				}
+				else if (ale->type == ACTTYPE_GPLAYER) {
+					borderselect_gplayer_frames(ale->data, rectf.xmin, rectf.xmax, selectmode);
+				}
 				break;
 			case ACTEDIT_BORDERSEL_CHA: /* all in channel(s) */
 				if (!((ymax < rectf.ymin) || (ymin > rectf.ymax))) {
@@ -3452,6 +3729,9 @@ void borderselect_action (void)
 								select_ipo_bezier_keys(conchan->ipo, selectmode);
 						}
 					}
+					else if (ale->type == ACTTYPE_GPLAYER) {
+						select_gpencil_frames(ale->data, selectmode);
+					}
 				}
 				break;
 			default: /* any keyframe inside region defined by region */
@@ -3474,6 +3754,9 @@ void borderselect_action (void)
 								borderselect_ipo_key(conchan->ipo, rectf.xmin, rectf.xmax, selectmode);
 						}
 					}
+					else if (ale->type == ACTTYPE_GPLAYER) {
+						borderselect_gplayer_frames(ale->data, rectf.xmin, rectf.xmax, selectmode);
+					}
 				}
 			}
 			
@@ -3504,6 +3787,8 @@ static void mouse_action (int selectmode)
 	bActionChannel *achan= NULL;
 	bConstraintChannel *conchan= NULL;
 	IpoCurve *icu= NULL;
+	bGPdata *gpd = NULL;
+	bGPDlayer *gpl = NULL;
 	TimeMarker *marker, *pmarker;
 	
 	void *act_channel;
@@ -3514,6 +3799,7 @@ static void mouse_action (int selectmode)
 	data = get_action_context(&datatype);
 	if (data == NULL) return;
 	if (datatype == ACTCONT_ACTION) act= (bAction *)data;
+	if (datatype == ACTCONT_GPENCIL) gpd= (bGPdata *)data;
 
 	act_channel= get_nearest_action_key(&selx, &sel, &act_type, &achan);
 	marker= find_nearest_marker(SCE_MARKERS, 1);
@@ -3586,6 +3872,9 @@ static void mouse_action (int selectmode)
 			case ACTTYPE_GROUP:
 				agrp= (bActionGroup *)act_channel;
 				break;
+			case ACTTYPE_GPLAYER:
+				gpl= (bGPDlayer *)act_channel;
+				break;
 			default:
 				return;
 		}
@@ -3609,6 +3898,13 @@ static void mouse_action (int selectmode)
 					set_active_actiongroup(act, agrp, 1);
 				}
 			}
+			else if (datatype == ACTCONT_GPENCIL) {
+				deselect_action_channels(0);
+				
+				/* Highlight gpencil layer */
+				gpl->flag |= GP_LAYER_SELECT;
+				gpencil_layer_setactive(gpd, gpl);
+			}
 		}
 		
 		if (icu)
@@ -3625,6 +3921,8 @@ static void mouse_action (int selectmode)
 					select_ipo_key(conchan->ipo, selx, selectmode);
 			}
 		}
+		else if (gpl)
+			select_gpencil_frame(gpl, selx, selectmode);
 		
 		std_rmouse_transform(transform_action_keys);
 		
@@ -3641,6 +3939,7 @@ static void mouse_action (int selectmode)
 static void mouse_actionchannels (short mval[])
 {
 	bAction *act= G.saction->action;
+	bGPdata *gpd= G.saction->gpd;
 	void *data, *act_channel;
 	short datatype, chantype;
 	
@@ -3672,17 +3971,8 @@ static void mouse_actionchannels (short mval[])
 						select_action_group(act, agrp, SELECT_INVERT);
 					}
 					else if (G.qual == (LR_CTRLKEY|LR_SHIFTKEY)) {
-						bActionChannel *achan;
-						
 						/* select all in group (and deselect everthing else) */	
-						deselect_actionchannels(act, 0);
-						
-						for (achan= agrp->channels.first; achan && achan->grp==agrp; achan= achan->next) {
-							select_channel(act, achan, SELECT_ADD);
-							
-							/* messy... set active bone */
-							select_poseelement_by_name(achan->name, 1);
-						}
+						select_action_group_channels(act, agrp);
 						select_action_group(act, agrp, SELECT_ADD);
 					}
 					else {
@@ -3796,6 +4086,24 @@ static void mouse_actionchannels (short mval[])
 				}
 			}
 				break;
+		case ACTTYPE_GPLAYER:
+			{
+				bGPDlayer *gpl= (bGPDlayer *)act_channel;
+				
+				if (mval[0] >= (NAMEWIDTH-16)) {
+					/* toggle lock */
+					gpl->flag ^= GP_LAYER_LOCKED;
+				}
+				else if (mval[0] >= (NAMEWIDTH-32)) {
+					/* toggle hide */
+					gpl->flag ^= GP_LAYER_HIDE;
+				}
+				else {
+					/* select/deselect */
+					select_gplayer_channel(gpd, gpl, SELECT_INVERT);
+				}
+			}
+				break;
 		default:
 			return;
 	}
@@ -4462,7 +4770,7 @@ void winqreadactionspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 		case RIGHTMOUSE:
 			/* Clicking in the channel area */
 			if ((G.v2d->mask.xmin) && (mval[0] < NAMEWIDTH)) {
-				if (datatype == ACTCONT_ACTION) {
+				if (ELEM(datatype, ACTCONT_ACTION, ACTCONT_GPENCIL)) {
 					/* mouse is over action channels */
 					if (G.qual == LR_CTRLKEY)
 						numbuts_action();
@@ -4682,11 +4990,13 @@ void winqreadactionspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 			
 		case NKEY:
 			if (G.qual==0) {
-				numbuts_action();
-				
-				/* no panel (yet). current numbuts are not easy to put in panel... */
-				//add_blockhandler(curarea, ACTION_HANDLER_PROPERTIES, UI_PNL_TO_MOUSE);
-				//scrarea_queue_winredraw(curarea);
+				/* panel will not always show useful info! */
+				if (mval[0] > ACTWIDTH) {
+					add_blockhandler(curarea, ACTION_HANDLER_PROPERTIES, UI_PNL_TO_MOUSE);
+					scrarea_queue_winredraw(curarea);
+				}
+				else 
+					numbuts_action();
 			}
 			break;
 			
@@ -4810,8 +5120,12 @@ void winqreadactionspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 		case DELKEY:
 		case XKEY:
 			if (okee("Erase selected")) {
-				if (mval[0] < NAMEWIDTH)
-					delete_action_channels();
+				if (mval[0] < NAMEWIDTH) {
+					if (datatype == ACTCONT_ACTION)
+						delete_action_channels();
+					else if (datatype == ACTCONT_GPENCIL)
+						delete_gpencil_layers();
+				}
 				else
 					delete_action_keys();
 				
diff --git a/source/blender/src/editaction_gpencil.c b/source/blender/src/editaction_gpencil.c
new file mode 100644
index 00000000000..b91c5a8b332
--- /dev/null
+++ b/source/blender/src/editaction_gpencil.c
@@ -0,0 +1,549 @@
+/**
+ * $Id: editaction_gpencil.c 14881 2008-05-18 10:41:42Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+ 
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <math.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BMF_Api.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+
+#include "DNA_listBase.h"
+#include "DNA_action_types.h"
+#include "DNA_gpencil_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_view2d_types.h"
+
+#include "BKE_global.h"
+#include "BKE_utildefines.h"
+#include "BKE_blender.h"
+#include "BKE_ipo.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+#include "BIF_butspace.h"
+#include "BIF_graphics.h"
+#include "BIF_interface.h"
+#include "BIF_mywindow.h"
+#include "BIF_resources.h"
+#include "BIF_space.h"
+#include "BIF_screen.h"
+#include "BIF_toolbox.h"
+#include "BIF_toets.h"
+
+#include "BIF_editaction.h"
+#include "BSE_editaction_types.h"
+
+#include "BDR_gpencil.h"
+#include "BIF_drawgpencil.h"
+
+#include "BSE_drawipo.h"
+#include "BSE_headerbuttons.h"
+#include "BSE_time.h"
+#include "BSE_view.h"
+
+#include "blendef.h"
+#include "butspace.h"
+
+#include "PIL_time.h"			/* sleep				*/
+#include "mydevice.h"
+
+/* ***************************************** */
+/* NOTE ABOUT THIS FILE:
+ * 	This file contains code for editing Grease Pencil data in the Action Editor
+ *	as a 'keyframes', so that a user can adjust the timing of Grease Pencil drawings.
+ * 	Therefore, this file mostly contains functions for selecting Grease-Pencil frames.
+ */
+/* ***************************************** */
+/* Generics - Loopers */
+
+/* Loops over the gp-frames for a gp-layer, and applies the given callback */
+short gplayer_frames_looper (bGPDlayer *gpl, short (*gpf_cb)(bGPDframe *))
+{
+	bGPDframe *gpf;
+	
+	/* error checker */
+	if (gpl == NULL)
+		return 0;
+	
+	/* do loop */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		/* execute callback */
+		if (gpf_cb(gpf))
+			return 1;
+	}
+		
+	/* nothing to return */
+	return 0;
+}
+
+/* ****************************************** */
+/* Data Conversion Tools */
+
+/* make a listing all the gp-frames in a layer as cfraelems */
+void gplayer_make_cfra_list (bGPDlayer *gpl, ListBase *elems, short onlysel)
+{
+	bGPDframe *gpf;
+	CfraElem *ce;
+	
+	/* error checking */
+	if (ELEM(NULL, gpl, elems))
+		return;
+	
+	/* loop through gp-frames, adding */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if ((onlysel == 0) || (gpf->flag & GP_FRAME_SELECT)) {
+			ce= MEM_callocN(sizeof(CfraElem), "CfraElem");
+			
+			ce->cfra= gpf->framenum;
+			ce->sel= (gpf->flag & GP_FRAME_SELECT) ? 1 : 0;
+			
+			BLI_addtail(elems, ce);
+		}
+	}
+}
+
+/* ***************************************** */
+/* Selection Tools */
+
+/* check if one of the frames in this layer is selected */
+short is_gplayer_frame_selected (bGPDlayer *gpl)
+{
+	bGPDframe *gpf;
+	
+	/* error checking */
+	if (gpl == NULL) 
+		return 0;
+	
+	/* stop at the first one found */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if (gpf->flag & GP_FRAME_SELECT)
+			return 1;
+	}
+	
+	/* not found */
+	return 0;
+}
+
+/* helper function - select gp-frame based on SELECT_* mode */
+static void gpframe_select (bGPDframe *gpf, short select_mode)
+{
+	switch (select_mode) {
+		case SELECT_ADD:
+			gpf->flag |= GP_FRAME_SELECT;
+			break;
+		case SELECT_SUBTRACT:
+			gpf->flag &= ~GP_FRAME_SELECT;
+			break;
+		case SELECT_INVERT:
+			gpf->flag ^= GP_FRAME_SELECT;
+			break;
+	}
+}
+
+/* set all/none/invert select (like above, but with SELECT_* modes) */
+void select_gpencil_frames (bGPDlayer *gpl, short select_mode)
+{
+	bGPDframe *gpf;
+	
+	/* error checking */
+	if (gpl == NULL) 
+		return;
+		
+	/* handle according to mode */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		gpframe_select(gpf, select_mode);
+	}
+}
+
+/* set all/none/invert select */
+void set_gplayer_frame_selection (bGPDlayer *gpl, short mode)
+{
+	/* error checking */
+	if (gpl == NULL) 
+		return;
+		
+	/* convert mode to select_mode */
+	switch (mode) {
+		case 2:
+			mode= SELECT_INVERT;
+			break;
+		case 1:
+			mode= SELECT_ADD;
+			break;
+		case 0:
+			mode= SELECT_SUBTRACT;
+			break;
+		default:
+			return;
+	}
+	
+	/* now call the standard function */
+	select_gpencil_frames (gpl, mode);
+}
+
+void select_gpencil_frame (bGPDlayer *gpl, int selx, short select_mode)
+{
+	bGPDframe *gpf;
+   
+	/* search through frames for a match */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if (gpf->framenum == selx)
+			gpframe_select(gpf, select_mode);
+	}
+}
+
+void borderselect_gplayer_frames (bGPDlayer *gpl, float min, float max, short select_mode)
+{
+	bGPDframe *gpf;
+	
+	/* only select those frames which are in bounds */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if (IN_RANGE(gpf->framenum, min, max))
+			gpframe_select(gpf, select_mode);
+	}
+}
+
+
+/* De-selects or inverts the selection of Layers for a grease-pencil block
+ *	mode: 0 = default behaviour (select all), 1 = test if (de)select all, 2 = invert all 
+ */
+void deselect_gpencil_layers (bGPdata *gpd, short mode)
+{
+	ListBase act_data = {NULL, NULL};
+	bActListElem *ale;
+	int filter, sel=1;
+	
+	/* filter data */
+	filter= ACTFILTER_VISIBLE;
+	actdata_filter(&act_data, filter, gpd, ACTCONT_GPENCIL);
+	
+	/* See if we should be selecting or deselecting */
+	if (mode == 1) {
+		for (ale= act_data.first; ale; ale= ale->next) {
+			if (sel == 0) 
+				break;
+			
+			if (ale->flag & GP_LAYER_SELECT)
+				sel= 0;
+		}
+	}
+	else
+		sel= 0;
+		
+	/* Now set the flags */
+	for (ale= act_data.first; ale; ale= ale->next) {
+		bGPDlayer *gpl= (bGPDlayer *)ale->data;
+		
+		if (mode == 2)
+			gpl->flag ^= GP_LAYER_SELECT;
+		else if (sel)
+			gpl->flag |= GP_LAYER_SELECT;
+		else
+			gpl->flag &= ~GP_LAYER_SELECT;
+			
+		gpl->flag &= ~GP_LAYER_ACTIVE;
+	}
+	
+	/* Cleanup */
+	BLI_freelistN(&act_data);
+}
+
+/* ***************************************** */
+/* Frame Editing Tools */
+
+void delete_gpencil_layers (void)
+{
+	ListBase act_data = {NULL, NULL};
+	bActListElem *ale, *next;
+	bGPdata *gpd;
+	void *data;
+	short datatype;
+	int filter;
+	
+	/* determine what type of data we are operating on */
+	data = get_action_context(&datatype);
+	if (data == NULL) return;
+	if (datatype != ACTCONT_GPENCIL) return;
+	gpd= (bGPdata *)data;
+	
+	/* filter data */
+	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_CHANNELS | ACTFILTER_SEL);
+	actdata_filter(&act_data, filter, data, datatype);
+	
+	/* clean up grease-pencil layers */
+	for (ale= act_data.first; ale; ale= next) {
+		bGPDlayer *gpl= (bGPDlayer *)ale->data;
+		next= ale->next;
+		
+		/* free layer and its data */
+		if (SEL_GPL(gpl)) {
+			free_gpencil_frames(gpl);
+			BLI_freelinkN(&gpd->layers, gpl);
+		}
+		
+		/* free temp memory */
+		BLI_freelinkN(&act_data, ale);
+	}
+	
+	BIF_undo_push("Delete GPencil Layers");
+	allspace(REDRAWVIEW3D, 0);
+	allqueue(REDRAWACTION, 0);
+}
+
+/* Delete selected frames */
+void delete_gplayer_frames (bGPDlayer *gpl)
+{
+	bGPDframe *gpf, *gpfn;
+	
+	/* error checking */
+	if (gpl == NULL)
+		return;
+		
+	/* check for frames to delete */
+	for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
+		gpfn= gpf->next;
+		
+		if (gpf->flag & GP_FRAME_SELECT)
+			gpencil_layer_delframe(gpl, gpf);
+	}
+}
+
+/* Duplicate selected frames from given gp-layer */
+void duplicate_gplayer_frames (bGPDlayer *gpl)
+{
+	bGPDframe *gpf, *gpfn;
+	
+	/* error checking */
+	if (gpl == NULL)
+		return;
+	
+	/* duplicate selected frames  */
+	for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
+		gpfn= gpf->next;
+		
+		/* duplicate this frame */
+		if (gpf->flag & GP_FRAME_SELECT) {
+			bGPDframe *gpfd; 
+			bGPDstroke *gps;
+			
+			/* duplicate frame, and deselect self */
+			gpfd= MEM_dupallocN(gpf);
+			gpf->flag &= ~GP_FRAME_SELECT;
+			
+			/* duplicate list of strokes too */
+			duplicatelist(&gpfd->strokes, &gpf->strokes);
+			
+			/* dupalloc only makes another copy of mem, but doesn't adjust pointers */
+			for (gps= gpfd->strokes.first; gps; gps= gps->next) {
+				gps->points= MEM_dupallocN(gps->points);
+			}
+			
+			BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
+		}
+	}
+}
+
+/* -------------------------------------- */
+/* Snap Tools */
+
+static short snap_gpf_nearest (bGPDframe *gpf)
+{
+	if (gpf->flag & GP_FRAME_SELECT)
+		gpf->framenum= (int)(floor(gpf->framenum+0.5));
+	return 0;
+}
+
+static short snap_gpf_nearestsec (bGPDframe *gpf)
+{
+	float secf = FPS;
+	if (gpf->flag & GP_FRAME_SELECT)
+		gpf->framenum= (int)(floor(gpf->framenum/secf + 0.5f) * secf);
+	return 0;
+}
+
+static short snap_gpf_cframe (bGPDframe *gpf)
+{
+	if (gpf->flag & GP_FRAME_SELECT)
+		gpf->framenum= (int)CFRA;
+	return 0;
+}
+
+static short snap_gpf_nearmarker (bGPDframe *gpf)
+{
+	if (gpf->flag & GP_FRAME_SELECT)
+		gpf->framenum= (int)find_nearest_marker_time(gpf->framenum);
+	return 0;
+}
+
+
+/* snap selected frames to ... */
+void snap_gplayer_frames (bGPDlayer *gpl, short mode)
+{
+	switch (mode) {
+		case 1: /* snap to nearest frame */
+			gplayer_frames_looper(gpl, snap_gpf_nearest);
+			break;
+		case 2: /* snap to current frame */
+			gplayer_frames_looper(gpl, snap_gpf_cframe);
+			break;
+		case 3: /* snap to nearest marker */
+			gplayer_frames_looper(gpl, snap_gpf_nearmarker);
+			break;
+		case 4: /* snap to nearest second */
+			gplayer_frames_looper(gpl, snap_gpf_nearestsec);
+			break;
+		default: /* just in case */
+			gplayer_frames_looper(gpl, snap_gpf_nearest);
+			break;
+	}
+}
+
+/* -------------------------------------- */
+/* Mirror Tools */
+
+static short mirror_gpf_cframe (bGPDframe *gpf)
+{
+	float diff;
+	
+	if (gpf->flag & GP_FRAME_SELECT) {
+		diff= ((float)CFRA - gpf->framenum);
+		gpf->framenum= ((float)CFRA + diff);
+	}
+	
+	return 0;
+}
+
+static short mirror_gpf_yaxis (bGPDframe *gpf)
+{
+	float diff;
+	
+	if (gpf->flag & GP_FRAME_SELECT) {
+		diff= (0.0f - gpf->framenum);
+		gpf->framenum= (0.0f + diff);
+	}
+	
+	return 0;
+}
+
+static short mirror_gpf_xaxis (bGPDframe *gpf)
+{
+	float diff;
+	
+	if (gpf->flag & GP_FRAME_SELECT) {
+		diff= (0.0f - gpf->framenum);
+		gpf->framenum= (0.0f + diff);
+	}
+	
+	return 0;
+}
+
+static short mirror_gpf_marker (bGPDframe *gpf)
+{
+	static TimeMarker *marker;
+	static short initialised = 0;
+	float diff;
+	
+	/* In order for this mirror function to work without
+	 * any extra arguments being added, we use the case
+	 * of bezt==NULL to denote that we should find the 
+	 * marker to mirror over. The static pointer is safe
+	 * to use this way, as it will be set to null after 
+	 * each cycle in which this is called.
+	 */
+	
+	if (gpf) {
+		/* mirroring time */
+		if ((gpf->flag & GP_FRAME_SELECT) && (marker)) {
+			diff= (marker->frame - gpf->framenum);
+			gpf->framenum= (marker->frame + diff);
+		}
+	}
+	else {
+		/* initialisation time */
+		if (initialised) {
+			/* reset everything for safety */
+			marker = NULL;
+			initialised = 0;
+		}
+		else {
+			/* try to find a marker */
+			for (marker= G.scene->markers.first; marker; marker=marker->next) {
+				if (marker->flag & SELECT) {
+					initialised = 1;
+					break;
+				}
+			}
+			
+			if (initialised == 0) 
+				marker = NULL;
+		}
+	}
+	
+	return 0;
+}
+
+
+/* mirror selected gp-frames on... */
+void mirror_gplayer_frames (bGPDlayer *gpl, short mode)
+{
+	switch (mode) {
+		case 1: /* mirror over current frame */
+			gplayer_frames_looper(gpl, mirror_gpf_cframe);
+			break;
+		case 2: /* mirror over frame 0 */
+			gplayer_frames_looper(gpl, mirror_gpf_yaxis);
+			break;
+		case 3: /* mirror over value 0 */
+			gplayer_frames_looper(gpl, mirror_gpf_xaxis);
+			break;
+		case 4: /* mirror over marker */
+			mirror_gpf_marker(NULL);
+			gplayer_frames_looper(gpl, mirror_gpf_marker);
+			mirror_gpf_marker(NULL);
+			break;
+		default: /* just in case */
+			gplayer_frames_looper(gpl, mirror_gpf_yaxis);
+			break;
+	}
+}
+
+/* ***************************************** */
diff --git a/source/blender/src/editmesh.c b/source/blender/src/editmesh.c
index 9eef61e11f9..188f7476728 100644
--- a/source/blender/src/editmesh.c
+++ b/source/blender/src/editmesh.c
@@ -340,8 +340,9 @@ void free_editface(EditFace *efa)
 #endif
 	EM_remove_selection(efa, EDITFACE);
 	
-	if (G.editMesh->act_face==efa)
-		EM_set_actFace(NULL);
+	if (G.editMesh->act_face==efa) {
+		EM_set_actFace( G.editMesh->faces.first == efa ? NULL : G.editMesh->faces.first);
+	}
 		
 	CustomData_em_free_block(&G.editMesh->fdata, &efa->data);
 	if(efa->fast==0)
@@ -1059,7 +1060,11 @@ void make_editMesh()
 	EM_hide_reset();
 	/* sets helper flags which arent saved */
 	EM_fgon_flags();
-
+	
+	if (EM_get_actFace(0)==NULL) {
+		EM_set_actFace( G.editMesh->faces.first ); /* will use the first face, this is so we alwats have an active face */
+	}
+		
 	/* vertex coordinates change with cache edit, need to recalc */
 	if(cacheedit)
 		recalc_editnormals();
diff --git a/source/blender/src/editnode.c b/source/blender/src/editnode.c
index 4c7334c55e0..5c137e67c1a 100644
--- a/source/blender/src/editnode.c
+++ b/source/blender/src/editnode.c
@@ -82,6 +82,7 @@
 #include "BLI_storage_types.h"
 
 #include "BDR_editobject.h"
+#include "BDR_gpencil.h"
 
 #include "RE_pipeline.h"
 #include "IMB_imbuf_types.h"
@@ -2305,6 +2306,7 @@ static int node_uiDoBlocks(ScrArea *sa, short event)
 	SpaceNode *snode= sa->spacedata.first;
 	ListBase *lb= &sa->uiblocks;
 	ListBase listb= *lb;
+	uiBlock *block;
 	bNode *node;
 	rctf rect;
 	void *prev, *next;
@@ -2319,13 +2321,36 @@ static int node_uiDoBlocks(ScrArea *sa, short event)
 		return UI_NOTHING;
 	}
 	
+	/* evil hack: try to do grease-pencil floating panel (like for nodes) */
+	block= uiGetBlock("nodes_panel_gpencil", sa);
+	if (block) {
+		/* try to process events here... if failed, just carry on */
+			/* when there's menus, the prev pointer becomes zero! */
+		prev= ((struct Link *)block)->prev;
+		next= ((struct Link *)block)->next;
+		((struct Link *)block)->prev= NULL;
+		((struct Link *)block)->next= NULL;
+		
+		lb->first= lb->last= block;
+		retval= uiDoBlocks(lb, event, 1);
+		
+		((struct Link *)block)->prev= prev;
+		((struct Link *)block)->next= next;
+		
+		*lb= listb;
+		
+		/* if something happened, get the heck outta here */
+		if (retval != UI_NOTHING)
+			return retval;
+	}
+	
+	
 	rect.xmin -= 2.0f;
 	rect.ymin -= 2.0f;
 	rect.xmax = rect.xmin + 4.0f;
 	rect.ymax = rect.ymin + 4.0f;
 	
 	for(node= snode->edittree->nodes.first; node; node= node->next) {
-		uiBlock *block;
 		char str[32];
 		
 		/* retreive unique block name, see also drawnode.c */
@@ -2369,14 +2394,16 @@ void winqreadnodespace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 	if(snode->nodetree==NULL) return;
 	
 	if(val) {
-
-		if( node_uiDoBlocks(sa, event)!=UI_NOTHING ) event= 0;	
-
+		if( node_uiDoBlocks(sa, event)!=UI_NOTHING ) event= 0;
+		
 		fromlib= (snode->id && snode->id->lib);
 		
 		switch(event) {
 		case LEFTMOUSE:
-			if(fromlib) {
+			if(gpencil_do_paint(sa)) {
+				return;
+			}
+			else if(fromlib) {
 				if(node_mouse_groupheader(snode)==0)
 					node_mouse_select(snode, event);
 			}
diff --git a/source/blender/src/editobject.c b/source/blender/src/editobject.c
index 2e5785eaab8..6af4f47ed11 100644
--- a/source/blender/src/editobject.c
+++ b/source/blender/src/editobject.c
@@ -5505,6 +5505,7 @@ void selectlinks(int nr)
 		allqueue(REDRAWDATASELECT, 0);
 		allqueue(REDRAWOOPS, 0);
 		BIF_undo_push("Select linked");
+		countall();
 	}
 }
 
diff --git a/source/blender/src/editsound.c b/source/blender/src/editsound.c
index 1cb7ec276cb..05eb094a7c2 100644
--- a/source/blender/src/editsound.c
+++ b/source/blender/src/editsound.c
@@ -148,7 +148,7 @@ void winqreadsoundspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 					first= 0;
 					CFRA= cfra;
 					update_for_newframe();
-					force_draw_plus(SPACE_VIEW3D, 1);
+					force_draw_all(0);
 				}
 				else PIL_sleep_ms(30);
 			
diff --git a/source/blender/src/gpencil.c b/source/blender/src/gpencil.c
new file mode 100644
index 00000000000..fa32b0ac7d4
--- /dev/null
+++ b/source/blender/src/gpencil.c
@@ -0,0 +1,1290 @@
+/**
+ * $Id: gpencil.c 14881 2008-05-18 10:41:42Z aligorith $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008, Blender Foundation
+ * This is a new part of Blender
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+ 
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <math.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BMF_Api.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+
+#include "DNA_listBase.h"
+#include "DNA_gpencil_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_view3d_types.h"
+
+#include "BKE_global.h"
+#include "BKE_utildefines.h"
+#include "BKE_blender.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+#include "BIF_butspace.h"
+#include "BIF_graphics.h"
+#include "BIF_interface.h"
+#include "BIF_mywindow.h"
+#include "BIF_resources.h"
+#include "BIF_space.h"
+#include "BIF_screen.h"
+#include "BIF_toolbox.h"
+#include "BIF_toets.h"
+
+#include "BDR_gpencil.h"
+#include "BIF_drawgpencil.h"
+
+#include "BSE_drawipo.h"
+#include "BSE_headerbuttons.h"
+#include "BSE_view.h"
+
+#include "blendef.h"
+
+#include "PIL_time.h"			/* sleep				*/
+#include "mydevice.h"
+
+/* ************************************************** */
+/* GENERAL STUFF */
+
+/* --------- Memory Management ------------ */
+
+/* Free strokes belonging to a gp-frame */
+void free_gpencil_strokes (bGPDframe *gpf)
+{
+	bGPDstroke *gps, *gpsn;
+	
+	/* error checking */
+	if (gpf == NULL) return;
+	
+	/* free strokes */
+	for (gps= gpf->strokes.first; gps; gps= gpsn) {
+		gpsn= gps->next;
+		
+		/* free stroke memory arrays, then stroke itself */
+		MEM_freeN(gps->points);
+		BLI_freelinkN(&gpf->strokes, gps);
+	}
+}
+
+/* Free all of a gp-layer's frames */
+void free_gpencil_frames (bGPDlayer *gpl)
+{
+	bGPDframe *gpf, *gpfn;
+	
+	/* error checking */
+	if (gpl == NULL) return;
+	
+	/* free frames */
+	for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
+		gpfn= gpf->next;
+		
+		/* free strokes and their associated memory */
+		free_gpencil_strokes(gpf);
+		BLI_freelinkN(&gpl->frames, gpf);
+	}
+}
+
+/* Free all of the gp-layers for a viewport (list should be &G.vd->gpd or so) */
+void free_gpencil_layers (ListBase *list) 
+{
+	bGPDlayer *gpl, *gpln;
+	
+	/* error checking */
+	if (list == NULL) return;
+	
+	/* delete layers*/
+	for (gpl= list->first; gpl; gpl= gpln) {
+		gpln= gpl->next;
+		
+		/* free layers and their data */
+		free_gpencil_frames(gpl);
+		BLI_freelinkN(list, gpl);
+	}
+}
+
+/* Free gp-data and all it's related data */
+void free_gpencil_data (bGPdata *gpd)
+{
+	/* free layers then data itself */
+	free_gpencil_layers(&gpd->layers);
+	MEM_freeN(gpd);
+}
+
+/* -------- Container Creation ---------- */
+
+/* add a new gp-frame to the given layer */
+bGPDframe *gpencil_frame_addnew (bGPDlayer *gpl, int cframe)
+{
+	bGPDframe *gpf, *gf;
+	short state=0;
+	
+	/* error checking */
+	if ((gpl == NULL) || (cframe <= 0))
+		return NULL;
+		
+	/* allocate memory for this frame */
+	gpf= MEM_callocN(sizeof(bGPDframe), "bGPDframe");
+	gpf->framenum= cframe;
+	
+	/* find appropriate place to add frame */
+	if (gpl->frames.first) {
+		for (gf= gpl->frames.first; gf; gf= gf->next) {
+			/* check if frame matches one that is supposed to be added */
+			if (gf->framenum == cframe) {
+				state= -1;
+				break;
+			}
+			
+			/* if current frame has already exceeded the frame to add, add before */
+			if (gf->framenum > cframe) {
+				BLI_insertlinkbefore(&gpl->frames, gf, gpf);
+				state= 1;
+				break;
+			}
+		}
+	}
+	
+	/* check whether frame was added successfully */
+	if (state == -1) {
+		MEM_freeN(gpf);
+		printf("Error: frame (%d) existed already for this layer \n", cframe);
+	}
+	else if (state == 0) {
+		/* add to end then! */
+		BLI_addtail(&gpl->frames, gpf);
+	}
+	
+	/* return frame */
+	return gpf;
+}
+
+/* add a new gp-layer and make it the active layer */
+bGPDlayer *gpencil_layer_addnew (bGPdata *gpd)
+{
+	bGPDlayer *gpl;
+	
+	/* check that list is ok */
+	if (gpd == NULL)
+		return NULL;
+		
+	/* allocate memory for frame and add to end of list */
+	gpl= MEM_callocN(sizeof(bGPDlayer), "bGPDlayer");
+	
+	/* add to datablock */
+	BLI_addtail(&gpd->layers, gpl);
+	
+	/* set basic settings */
+	gpl->color[3]= 1.0f;
+	gpl->thickness = 1;
+	
+	/* auto-name */
+	sprintf(gpl->info, "GP_Layer");
+	BLI_uniquename(&gpd->layers, gpl, "GP_Layer", offsetof(bGPDlayer, info[0]), 128);
+	
+	/* make this one the active one */
+	gpencil_layer_setactive(gpd, gpl);
+	
+	/* return layer */
+	return gpl;
+}
+
+/* add a new gp-datablock */
+bGPdata *gpencil_data_addnew (void)
+{
+	bGPdata *gpd;
+	
+	/* allocate memory for a new block */
+	gpd= MEM_callocN(sizeof(bGPdata), "GreasePencilData");
+	
+	/* initial settings */
+		/* it is quite useful to be able to see this info, so on by default */
+	gpd->flag = GP_DATA_DISPINFO;
+	
+	return gpd;
+}
+
+/* -------- Data Duplication ---------- */
+
+/* make a copy of a given gpencil datablock */
+bGPdata *gpencil_data_duplicate (bGPdata *src)
+{
+	bGPdata *dst;
+	bGPDlayer *gpld, *gpls;
+	bGPDframe *gpfd, *gpfs;
+	bGPDstroke *gps;
+	
+	/* error checking */
+	if (src == NULL)
+		return NULL;
+	
+	/* make a copy of the base-data */
+	dst= MEM_dupallocN(src);
+	
+	/* copy layers */
+	duplicatelist(&dst->layers, &src->layers);
+	
+	for (gpld=dst->layers.first, gpls=src->layers.first; gpld && gpls; 
+		 gpld=gpld->next, gpls=gpls->next) 
+	{
+		/* copy frames */
+		duplicatelist(&gpld->frames, &gpls->frames);
+		
+		for (gpfd=gpld->frames.first, gpfs=gpls->frames.first; gpfd && gpfs;
+			 gpfd=gpfd->next, gpfs=gpfs->next) 
+		{
+			/* copy strokes */
+			duplicatelist(&gpfd->strokes, &gpfs->strokes);
+			
+			for (gps= gpfd->strokes.first; gps; gps= gps->next) 
+			{
+				gps->points= MEM_dupallocN(gps->points);
+			}
+		}
+	}
+	
+	/* return new */
+	return dst;
+}
+
+/* ----------- GP-Datablock API ------------- */
+
+/* get the appropriate bGPdata from the active/given context */
+bGPdata *gpencil_data_getactive (ScrArea *sa)
+{
+	/* error checking */
+	if ((sa == NULL) && (curarea == NULL))
+		return NULL;
+	if (sa == NULL)
+		sa= curarea;
+		
+	/* handle depending on spacetype */
+	switch (sa->spacetype) {
+		case SPACE_VIEW3D:
+		{
+			View3D *v3d= sa->spacedata.first;
+			return v3d->gpd;
+		}
+			break;
+		case SPACE_NODE:
+		{
+			SpaceNode *snode= sa->spacedata.first;
+			return snode->gpd;
+		}
+			break;
+		case SPACE_SEQ:
+		{
+			SpaceSeq *sseq= sa->spacedata.first;
+			
+			/* only applicable for "Image Preview" mode */
+			if (sseq->mainb)
+				return sseq->gpd;
+		}
+			break;
+	}
+	
+	/* nothing found */
+	return NULL;
+}
+
+/* set bGPdata for the active/given context, and return success/fail */
+short gpencil_data_setactive (ScrArea *sa, bGPdata *gpd)
+{
+	/* error checking */
+	if ((sa == NULL) && (curarea == NULL))
+		return 0;
+	if (gpd == NULL)
+		return 0;
+	if (sa == NULL)
+		sa= curarea;
+	
+	/* handle depending on spacetype */
+	// TODO: someday we should have multi-user data, so no need to loose old data
+	switch (sa->spacetype) {
+		case SPACE_VIEW3D:
+		{
+			View3D *v3d= sa->spacedata.first;
+			
+			/* free the existing block */
+			if (v3d->gpd)
+				free_gpencil_data(v3d->gpd);
+			v3d->gpd= gpd;
+			
+			return 1;
+		}
+			break;
+		case SPACE_NODE:
+		{
+			SpaceNode *snode= sa->spacedata.first;
+			
+			/* free the existing block */
+			if (snode->gpd)
+				free_gpencil_data(snode->gpd);
+			snode->gpd= gpd;
+			
+			/* set special settings */
+			gpd->flag |= GP_DATA_VIEWALIGN;
+			
+			return 1;
+		}
+			break;
+		case SPACE_SEQ:
+		{
+			SpaceSeq *sseq= sa->spacedata.first;
+			
+			/* only applicable if right mode */
+			if (sseq->mainb) {
+				/* free the existing block */
+				if (sseq->gpd)
+					free_gpencil_data(sseq->gpd);
+				sseq->gpd= gpd;
+				
+				return 1;
+			}
+		}
+			break;
+	}
+	
+	/* failed to add */
+	return 0;
+}
+
+/* Find gp-data destined for editing in animation editor (for editing time) */
+bGPdata *gpencil_data_getetime (bScreen *sc)
+{
+	bGPdata *gpd= NULL;
+	ScrArea *sa;
+	
+	/* error checking */
+	if (sc == NULL)
+		return NULL;
+	
+	/* search through areas, checking if an appropriate gp-block is available 
+	 * (this assumes that only one will have the active flag set)
+	 */
+	for (sa= sc->areabase.first; sa; sa= sa->next) {
+		/* handle depending on space type */
+		switch (sa->spacetype) {
+			case SPACE_VIEW3D: /* 3d-view */
+			{
+				View3D *v3d= sa->spacedata.first;
+				gpd= v3d->gpd;
+			}
+				break;
+			case SPACE_NODE: /* Node Editor */
+			{
+				SpaceNode *snode= sa->spacedata.first;
+				gpd= snode->gpd;
+			}
+				break;
+			case SPACE_SEQ: /* Sequence Editor - Image Preview */
+			{
+				SpaceSeq *sseq= sa->spacedata.first;
+				
+				if (sseq->mainb)
+					gpd= sseq->gpd;
+				else
+					gpd= NULL;
+			}
+				break;
+				
+			default: /* unsupported space-type */
+				gpd= NULL;
+				break;
+		}
+		
+		/* check if ok */
+		if ((gpd) && (gpd->flag & GP_DATA_EDITTIME))
+			return gpd;
+	}
+	
+	/* didn't find a match */
+	return NULL;
+}
+
+/* make sure only the specified view can have gp-data for time editing 
+ *	- gpd can be NULL, if we wish to make sure no gp-data is being edited
+ */
+void gpencil_data_setetime (bScreen *sc, bGPdata *gpd)
+{
+	bGPdata *gpdn= NULL;
+	ScrArea *sa;
+	
+	/* error checking */
+	if (sc == NULL)
+		return;
+	
+	/* search through areas, checking if an appropriate gp-block is available 
+	 * (this assumes that only one will have the active flag set)
+	 */
+	for (sa= sc->areabase.first; sa; sa= sa->next) {
+		/* handle depending on space type */
+		switch (sa->spacetype) {
+			case SPACE_VIEW3D: /* 3d-view */
+			{
+				View3D *v3d= sa->spacedata.first;
+				gpdn= v3d->gpd;
+			}
+				break;
+			case SPACE_NODE: /* Node Editor */
+			{
+				SpaceNode *snode= sa->spacedata.first;
+				gpdn= snode->gpd;
+			}
+				break;
+			case SPACE_SEQ: /* Sequence Editor - Image Preview */
+			{
+				SpaceSeq *sseq= sa->spacedata.first;
+				gpdn= sseq->gpd;
+			}
+				break;
+				
+			default: /* unsupported space-type */
+				gpdn= NULL;
+				break;
+		}
+		
+		/* clear flag if a gp-data block found */
+		if (gpdn)
+			gpdn->flag &= ~GP_DATA_EDITTIME;
+	}
+	
+	/* set active flag for this block (if it is provided) */
+	if (gpd)
+		gpd->flag |= GP_DATA_EDITTIME;
+}
+
+/* -------- GP-Frame API ---------- */
+
+/* delete the last stroke of the given frame */
+void gpencil_frame_delete_laststroke (bGPDframe *gpf)
+{
+	bGPDstroke *gps= (gpf) ? gpf->strokes.last : NULL;
+	
+	/* error checking */
+	if (ELEM(NULL, gpf, gps))
+		return;
+	
+	/* free the stroke and its data */
+	MEM_freeN(gps->points);
+	BLI_freelinkN(&gpf->strokes, gps);
+}
+
+/* -------- GP-Layer API ---------- */
+
+/* get the appropriate gp-frame from a given layer
+ *	- this sets the layer's actframe var (if allowed to)
+ *	- extension beyond range (if first gp-frame is after all frame in interest and cannot add)
+ */
+bGPDframe *gpencil_layer_getframe (bGPDlayer *gpl, int cframe, short addnew)
+{
+	bGPDframe *gpf = NULL;
+	short found = 0;
+	
+	/* error checking */
+	if (gpl == NULL) return NULL;
+	if (cframe <= 0) cframe = 1;
+	
+	/* check if there is already an active frame */
+	if (gpl->actframe) {
+		gpf= gpl->actframe;
+		
+		/* do not allow any changes to layer's active frame if layer is locked */
+		if (gpl->flag & GP_LAYER_LOCKED)
+			return gpf;
+		/* do not allow any changes to actframe if frame has painting tag attached to it */
+		if (gpf->flag & GP_FRAME_PAINT) 
+			return gpf;
+		
+		/* try to find matching frame */
+		if (gpf->framenum < cframe) {
+			for (; gpf; gpf= gpf->next) {
+				if (gpf->framenum == cframe) {
+					found= 1;
+					break;
+				}
+				else if ((gpf->next) && (gpf->next->framenum > cframe)) {
+					found= 1;
+					break;
+				}
+			}
+			
+			/* set the appropriate frame */
+			if (addnew) {
+				if ((found) && (gpf->framenum == cframe))
+					gpl->actframe= gpf;
+				else
+					gpl->actframe= gpencil_frame_addnew(gpl, cframe);
+			}
+			else if (found)
+				gpl->actframe= gpf;
+			else
+				gpl->actframe= gpl->frames.last;
+		}
+		else {
+			for (; gpf; gpf= gpf->prev) {
+				if (gpf->framenum <= cframe) {
+					found= 1;
+					break;
+				}
+			}
+			
+			/* set the appropriate frame */
+			if (addnew) {
+				if ((found) && (gpf->framenum == cframe))
+					gpl->actframe= gpf;
+				else
+					gpl->actframe= gpencil_frame_addnew(gpl, cframe);
+			}
+			else if (found)
+				gpl->actframe= gpf;
+			else
+				gpl->actframe= gpl->frames.first;
+		}
+	}
+	else if (gpl->frames.first) {
+		/* check which of the ends to start checking from */
+		const int first= ((bGPDframe *)(gpl->frames.first))->framenum;
+		const int last= ((bGPDframe *)(gpl->frames.last))->framenum;
+		
+		if (abs(cframe-first) > abs(cframe-last)) {
+			/* find gp-frame which is less than or equal to cframe */
+			for (gpf= gpl->frames.last; gpf; gpf= gpf->prev) {
+				if (gpf->framenum <= cframe) {
+					found= 1;
+					break;
+				}
+			}
+		}
+		else {
+			/* find gp-frame which is less than or equal to cframe */
+			for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+				if (gpf->framenum <= cframe) {
+					found= 1;
+					break;
+				}
+			}
+		}
+		
+		/* set the appropriate frame */
+		if (addnew) {
+			if ((found) && (gpf->framenum == cframe))
+				gpl->actframe= gpf;
+			else
+				gpl->actframe= gpencil_frame_addnew(gpl, cframe);
+		}
+		else if (found)
+			gpl->actframe= gpf;
+		else {
+			/* unresolved errogenous situation! */
+			printf("Error: cannot find appropriate gp-frame \n");
+		}
+	}
+	else {
+		/* currently no frames (add if allowed to) */
+		if (addnew)
+			gpl->actframe= gpencil_frame_addnew(gpl, cframe);
+		else {
+			/* don't do anything... this may be when no frames yet! */
+		}
+	}
+	
+	/* return */
+	return gpl->actframe;
+}
+
+/* delete the given frame from a layer */
+void gpencil_layer_delframe (bGPDlayer *gpl, bGPDframe *gpf)
+{
+	/* error checking */
+	if (ELEM(NULL, gpl, gpf))
+		return;
+		
+	/* free the frame and its data */
+	free_gpencil_strokes(gpf);
+	BLI_freelinkN(&gpl->frames, gpf);
+	gpl->actframe = NULL;
+}
+
+/* get the active gp-layer for editing */
+bGPDlayer *gpencil_layer_getactive (bGPdata *gpd)
+{
+	bGPDlayer *gpl;
+	
+	/* error checking */
+	if (ELEM(NULL, gpd, gpd->layers.first))
+		return NULL;
+		
+	/* loop over layers until found (assume only one active) */
+	for (gpl=gpd->layers.first; gpl; gpl=gpl->next) {
+		if (gpl->flag & GP_LAYER_ACTIVE)
+			return gpl;
+	}
+	
+	/* no active layer found */
+	return NULL;
+}
+
+/* set the active gp-layer */
+void gpencil_layer_setactive (bGPdata *gpd, bGPDlayer *active)
+{
+	bGPDlayer *gpl;
+	
+	/* error checking */
+	if (ELEM3(NULL, gpd, gpd->layers.first, active))
+		return;
+		
+	/* loop over layers deactivating all */
+	for (gpl=gpd->layers.first; gpl; gpl=gpl->next)
+		gpl->flag &= ~GP_LAYER_ACTIVE;
+	
+	/* set as active one */
+	active->flag |= GP_LAYER_ACTIVE;
+}
+
+/* delete the active gp-layer */
+void gpencil_layer_delactive (bGPdata *gpd)
+{
+	bGPDlayer *gpl= gpencil_layer_getactive(gpd);
+	
+	/* error checking */
+	if (ELEM(NULL, gpd, gpl)) 
+		return;
+	
+	/* free layer */	
+	free_gpencil_frames(gpl);
+	BLI_freelinkN(&gpd->layers, gpl);
+
+}
+
+/* ************************************************** */
+/* GREASE-PENCIL EDITING MODE - Tools */
+
+/* --------- Data Deletion ---------- */
+
+/* delete the last stroke on the active layer */
+void gpencil_delete_laststroke (bGPdata *gpd)
+{
+	bGPDlayer *gpl= gpencil_layer_getactive(gpd);
+	bGPDframe *gpf= gpencil_layer_getframe(gpl, CFRA, 0);
+	
+	gpencil_frame_delete_laststroke(gpf);
+}
+
+/* delete the active frame */
+void gpencil_delete_actframe (bGPdata *gpd)
+{
+	bGPDlayer *gpl= gpencil_layer_getactive(gpd);
+	bGPDframe *gpf= gpencil_layer_getframe(gpl, CFRA, 0);
+	
+	gpencil_layer_delframe(gpl, gpf);
+}
+
+
+
+/* delete various grase-pencil elements 
+ *	mode: 	1 - last stroke
+ *		 	2 - active frame
+ *			3 - active layer
+ */
+void gpencil_delete_operation (short mode) // unused
+{
+	bGPdata *gpd;
+	
+	/* get datablock to work on */
+	gpd= gpencil_data_getactive(NULL);
+	if (gpd == NULL) return;
+	
+	switch (mode) {
+		case 1: /* last stroke */
+			gpencil_delete_laststroke(gpd);
+			break;
+		case 2: /* active frame */
+			gpencil_delete_actframe(gpd);
+			break;
+		case 3: /* active layer */
+			gpencil_layer_delactive(gpd);
+			break;
+	}
+	
+	/* redraw and undo-push */
+	BIF_undo_push("GPencil Delete");
+	allqueue(REDRAWVIEW3D, 0);
+}
+
+/* display a menu for deleting different grease-pencil elements */
+void gpencil_delete_menu (void) // unused
+{
+	short mode;
+	
+	mode= pupmenu("Erase...%t|Last Stroke%x1|Active Frame%x2|Active Layer%x3");
+	if (mode <= 0) return;
+	
+	gpencil_delete_operation(mode);
+}
+
+/* ************************************************** */
+/* GREASE-PENCIL EDITING MODE - Painting */
+
+/* ---------- 'Globals' and Defines ----------------- */
+
+/* maximum sizes of gp-session buffer */
+#define GP_STROKE_BUFFER_MAX	500	
+
+/* ------ */
+
+/* Temporary 'Stroke' Operation data */
+typedef struct tGPsdata {
+	ScrArea *sa;		/* area where painting originated */
+	View2D *v2d;		/* needed for GP_STROKE_2DSPACE */
+	
+	bGPdata *gpd;		/* gp-datablock layer comes from */
+	bGPDlayer *gpl;		/* layer we're working on */
+	bGPDframe *gpf;		/* frame we're working on */
+	
+	short status;		/* current status of painting */
+	short paintmode;	/* mode for painting (L_MOUSE or R_MOUSE for now) */
+} tGPsdata;
+
+/* values for tGPsdata->status */
+enum {
+	GP_STATUS_NORMAL = 0,	/* running normally */
+	GP_STATUS_ERROR,		/* something wasn't correctly set up */
+	GP_STATUS_DONE			/* painting done */
+};
+
+/* Return flags for adding points to stroke buffer */
+enum {
+	GP_STROKEADD_INVALID	= -2,		/* error occurred - insufficient info to do so */
+	GP_STROKEADD_OVERFLOW	= -1,		/* error occurred - cannot fit any more points */
+	GP_STROKEADD_NORMAL,				/* point was successfully added */
+	GP_STROKEADD_FULL					/* cannot add any more points to buffer */
+};
+
+/* ---------- Stroke Editing ------------ */
+
+/* clear the session buffers (call this before AND after a paint operation) */
+static void gp_session_validatebuffer (tGPsdata *p)
+{
+	bGPdata *gpd= p->gpd;
+	
+	/* clear memory of buffer (or allocate it if starting a new session) */
+	if (gpd->sbuffer)
+		memset(gpd->sbuffer, 0, sizeof(bGPDspoint)*GP_STROKE_BUFFER_MAX);
+	else
+		gpd->sbuffer= MEM_callocN(sizeof(bGPDspoint)*GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer");
+	
+	/* reset indices */
+	gpd->sbuffer_size = 0;
+	
+	/* reset flags */
+	gpd->sbuffer_sflag= 0;
+}
+
+/* init new painting session */
+static void gp_session_initpaint (tGPsdata *p)
+{
+	/* clear previous data (note: is on stack) */
+	memset(p, 0, sizeof(tGPsdata));
+	
+	/* make sure the active view (at the starting time) is a 3d-view */
+	if (curarea == NULL) {
+		p->status= GP_STATUS_ERROR;
+		if (G.f & G_DEBUG) 
+			printf("Error: No active view for painting \n");
+		return;
+	}
+	switch (curarea->spacetype) {
+		/* supported views first */
+		case SPACE_VIEW3D:
+		{
+			View3D *v3d= curarea->spacedata.first;
+			
+			/* set current area */
+			p->sa= curarea;
+			
+			/* check that gpencil data is allowed to be drawn */
+			if ((v3d->flag2 & V3D_DISPGP)==0) {
+				p->status= GP_STATUS_ERROR;
+				if (G.f & G_DEBUG) 
+					printf("Error: In active view, Grease Pencil not shown \n");
+				return;
+			}
+		}
+			break;
+		case SPACE_NODE:
+		{
+			SpaceNode *snode= curarea->spacedata.first;
+			
+			/* set current area */
+			p->sa= curarea;
+			p->v2d= &snode->v2d;
+			
+			/* check that gpencil data is allowed to be drawn */
+			if ((snode->flag & SNODE_DISPGP)==0) {
+				p->status= GP_STATUS_ERROR;
+				if (G.f & G_DEBUG) 
+					printf("Error: In active view, Grease Pencil not shown \n");
+				return;
+			}
+		}
+			break;
+		case SPACE_SEQ:
+		{
+			SpaceSeq *sseq= curarea->spacedata.first;
+			
+			/* set current area */
+			p->sa= curarea;
+			p->v2d= &sseq->v2d;
+			
+			/* check that gpencil data is allowed to be drawn */
+			if (sseq->mainb == 0) {
+				p->status= GP_STATUS_ERROR;
+				if (G.f & G_DEBUG) 
+					printf("Error: In active view (sequencer), active mode doesn't support Grease Pencil \n");
+				return;
+			}
+			if ((sseq->flag & SEQ_DRAW_GPENCIL)==0) {
+				p->status= GP_STATUS_ERROR;
+				if (G.f & G_DEBUG) 
+					printf("Error: In active view, Grease Pencil not shown \n");
+				return;
+			}
+		}
+			break;	
+		/* unsupported views */
+		default:
+		{
+			p->status= GP_STATUS_ERROR;
+			if (G.f & G_DEBUG) 
+				printf("Error: Active view not appropriate for Grease Pencil drawing \n");
+			return;
+		}
+			break;
+	}
+	
+	/* get gp-data */
+	p->gpd= gpencil_data_getactive(p->sa);
+	if (p->gpd == NULL) {
+		short ok;
+		
+		p->gpd= gpencil_data_addnew();
+		ok= gpencil_data_setactive(p->sa, p->gpd);
+		
+		/* most of the time, the following check isn't needed */
+		if (ok == 0) {
+			/* free gpencil data as it can't be used */
+			free_gpencil_data(p->gpd);
+			p->gpd= NULL;
+			p->status= GP_STATUS_ERROR;
+			if (G.f & G_DEBUG) 
+				printf("Error: Could not assign newly created Grease Pencil data to active area \n");
+			return;
+		}
+	}
+	
+	/* set edit flags */
+	G.f |= G_GREASEPENCIL;
+	
+	/* clear out buffer (stored in gp-data) in case something contaminated it */
+	gp_session_validatebuffer(p);
+}
+
+/* cleanup after a painting session */
+static void gp_session_cleanup (tGPsdata *p)
+{
+	bGPdata *gpd= p->gpd;
+	
+	/* error checking */
+	if (gpd == NULL)
+		return;
+	
+	/* free stroke buffer */
+	if (gpd->sbuffer) {
+		MEM_freeN(gpd->sbuffer);
+		gpd->sbuffer= NULL;
+	}
+	
+	/* clear flags */
+	gpd->sbuffer_size= 0;
+	gpd->sbuffer_sflag= 0;
+}
+
+/* convert screen-coordinates to buffer-coordinates */
+static void gp_stroke_convertcoords (tGPsdata *p, short mval[], float out[])
+{
+	bGPdata *gpd= p->gpd;
+	
+	/* in 3d-space - pt->x/y/z are 3 side-by-side floats */
+	if (gpd->sbuffer_sflag & GP_STROKE_3DSPACE) {
+		short mx=mval[0], my=mval[1];
+		float *fp= give_cursor();
+		float dvec[3];
+		
+		/* method taken from editview.c - mouse_cursor() */
+		project_short_noclip(fp, mval);
+		window_to_3d(dvec, mval[0]-mx, mval[1]-my);
+		VecSubf(out, fp, dvec);
+	}
+	
+	/* 2d - on 'canvas' (assume that p->v2d is set) */
+	else if ((gpd->sbuffer_sflag & GP_STROKE_2DSPACE) && (p->v2d)) {
+		float x, y;
+		
+		areamouseco_to_ipoco(p->v2d, mval, &x, &y);
+		
+		out[0]= x;
+		out[1]= y;
+	}
+	
+	/* 2d - relative to screen (viewport area) */
+	else {
+		out[0] = (float)(mval[0]) / (float)(p->sa->winx) * 1000;
+		out[1] = (float)(mval[1]) / (float)(p->sa->winy) * 1000;
+	}
+}
+
+/* add current stroke-point to buffer (returns whether point was successfully added) */
+static short gp_stroke_addpoint (tGPsdata *p, short mval[], float pressure)
+{
+	bGPdata *gpd= p->gpd;
+	bGPDspoint *pt;
+	
+	/* check if still room in buffer */
+	if (gpd->sbuffer_size >= GP_STROKE_BUFFER_MAX)
+		return GP_STROKEADD_OVERFLOW;
+	
+	
+	/* get pointer to destination point */
+	pt= gpd->sbuffer + gpd->sbuffer_size;
+	
+	/* convert screen-coordinates to appropriate coordinates (and store them) */
+	gp_stroke_convertcoords(p, mval, &pt->x);
+	
+	/* store other settings */
+	pt->pressure= pressure;
+	
+	/* increment counters */
+	gpd->sbuffer_size++;
+	
+	/* check if another operation can still occur */
+	if (gpd->sbuffer_size == GP_STROKE_BUFFER_MAX)
+		return GP_STROKEADD_FULL;
+	else
+		return GP_STROKEADD_NORMAL;
+}
+
+/* smooth a stroke (in buffer) before storing it */
+static void gp_stroke_smooth (tGPsdata *p)
+{
+	bGPdata *gpd= p->gpd;
+	int i=0, cmx=gpd->sbuffer_size;
+	
+	/* don't try if less than 2 points in buffer */
+	if ((cmx <= 2) || (gpd->sbuffer == NULL))
+		return;
+	
+	/* apply weighting-average (note doing this along path sequentially does introduce slight error) */
+	for (i=0; i < gpd->sbuffer_size; i++) {
+		bGPDspoint *pc= (gpd->sbuffer + i);
+		bGPDspoint *pb= (i-1 > 0)?(pc-1):(pc);
+		bGPDspoint *pa= (i-2 > 0)?(pc-2):(pb);
+		bGPDspoint *pd= (i+1 < cmx)?(pc+1):(pc);
+		bGPDspoint *pe= (i+2 < cmx)?(pc+2):(pd);
+		
+		pc->x= (0.1*pa->x + 0.2*pb->x + 0.4*pc->x + 0.2*pd->x + 0.1*pe->x);
+		pc->y= (0.1*pa->y + 0.2*pb->y + 0.4*pc->y + 0.2*pd->y + 0.1*pe->y);
+	}
+}
+
+/* make a new stroke from the buffer data */
+static void gp_stroke_newfrombuffer (tGPsdata *p)
+{
+	bGPdata *gpd= p->gpd;
+	bGPDstroke *gps;
+	bGPDspoint *pt, *ptc;
+	int i, totelem;
+	
+	/* get total number of points to allocate space for */
+	totelem = gpd->sbuffer_size;
+	
+	/* exit with error if no valid points from this stroke */
+	if (totelem == 0) {
+		if (G.f & G_DEBUG) 
+			printf("Error: No valid points in stroke buffer to convert (tot=%d) \n", gpd->sbuffer_size);
+		return;
+	}
+	
+	/* allocate memory for a new stroke */
+	gps= MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
+	
+	/* allocate enough memory for a continuous array for storage points */
+	pt= gps->points= MEM_callocN(sizeof(bGPDspoint)*totelem, "gp_stroke_points");
+	
+	/* copy appropriate settings for stroke */
+	gps->totpoints= totelem;
+	gps->thickness= p->gpl->thickness;
+	gps->flag= gpd->sbuffer_sflag;
+	
+	/* copy points from the buffer to the stroke */
+	for (i=0, ptc=gpd->sbuffer; i < gpd->sbuffer_size && ptc; i++, ptc++) {
+		memcpy(pt, ptc, sizeof(bGPDspoint));
+		pt++;
+	}
+	
+	/* add stroke to frame */
+	BLI_addtail(&p->gpf->strokes, gps);
+}
+
+/* ---------- 'Paint' Tool ------------ */
+
+/* init new stroke */
+static void gp_paint_initstroke (tGPsdata *p)
+{	
+	/* get active layer (or add a new one if non-existent) */
+	p->gpl= gpencil_layer_getactive(p->gpd);
+	if (p->gpl == NULL)
+		p->gpl= gpencil_layer_addnew(p->gpd);
+	if (p->gpl->flag & GP_LAYER_LOCKED) {
+		p->status= GP_STATUS_ERROR;
+		if (G.f & G_DEBUG)
+			printf("Error: Cannot paint on locked layer \n");
+		return;
+	}
+		
+	/* get active frame (add a new one if not matching frame) */
+	p->gpf= gpencil_layer_getframe(p->gpl, CFRA, 1);
+	if (p->gpf == NULL) {
+		p->status= GP_STATUS_ERROR;
+		if (G.f & G_DEBUG) 
+			printf("Error: No frame created (gpencil_paint_init) \n");
+		return;
+	}
+	else
+		p->gpf->flag |= GP_FRAME_PAINT;
+		
+	/* check if points will need to be made in 3d-space */
+	if (p->gpd->flag & GP_DATA_VIEWALIGN) {
+		switch (p->sa->spacetype) {
+			case SPACE_VIEW3D:
+			{
+				float *fp= give_cursor();
+				initgrabz(fp[0], fp[1], fp[2]);
+				
+				p->gpd->sbuffer_sflag |= GP_STROKE_3DSPACE;
+			}
+				break;
+			case SPACE_NODE:
+			{
+				p->gpd->sbuffer_sflag |= GP_STROKE_2DSPACE;
+			}
+				break;
+			case SPACE_SEQ:
+			{
+				/* for now, this is not applicable here... */
+			}
+				break;
+		}
+	}
+}
+
+/* finish off a stroke (clears buffer, but doesn't finish the paint operation) */
+static void gp_paint_strokeend (tGPsdata *p)
+{
+	/* sanitize stroke-points in buffer */
+	gp_stroke_smooth(p);
+	
+	/* transfer stroke to frame */
+	gp_stroke_newfrombuffer(p);
+	
+	/* clean up buffer now */
+	gp_session_validatebuffer(p);
+}
+
+/* finish off stroke painting operation */
+static void gp_paint_cleanup (tGPsdata *p)
+{
+	/* finish off a stroke */
+	gp_paint_strokeend(p);
+	
+	/* "unlock" frame */
+	p->gpf->flag &= ~GP_FRAME_PAINT;
+	
+	/* add undo-push so stroke can be undone */
+	/* FIXME: currently disabled, as it's impossible to get this working nice
+	 * as gpenci data is on currently screen-level (which isn't saved to undo files)
+	 */
+	//BIF_undo_push("GPencil Stroke");
+	
+	/* force redraw after drawing action */
+	force_draw(0);
+}
+
+/* -------- */
+
+/* main call to paint a new stroke */
+short gpencil_paint (short mousebutton)
+{
+	tGPsdata p;
+	short prevmval[2], mval[2];
+	float opressure, pressure;
+	short ok = GP_STROKEADD_NORMAL;
+	
+	/* init paint-data */
+	gp_session_initpaint(&p);
+	if (p.status == GP_STATUS_ERROR) {
+		gp_session_cleanup(&p);
+		return 0;
+	}
+	gp_paint_initstroke(&p);
+	if (p.status == GP_STATUS_ERROR) {
+		gp_session_cleanup(&p);
+		return 0;
+	}
+	
+	/* set cursor to indicate drawing */
+	setcursor_space(p.sa->spacetype, CURSOR_VPAINT);
+	
+	/* init drawing-device settings */
+	getmouseco_areawin(mval);
+	pressure = get_pressure();
+	
+	prevmval[0]= mval[0];
+	prevmval[1]= mval[1];
+	opressure= pressure;
+	
+	/* only allow painting of single 'dots' if: 
+	 *	- pressure is not excessive (as it can be on some windows tablets)
+	 *	- draw-mode for active datablock is turned on
+	 */
+	if (!(pressure >= 0.99f) || (p.gpd->flag & GP_DATA_EDITPAINT)) { 
+		gp_stroke_addpoint(&p, mval, pressure);
+	}
+	
+	/* paint loop */
+	do {
+		/* get current user input */
+		getmouseco_areawin(mval);
+		pressure = get_pressure();
+		
+		/* only add current point to buffer if mouse moved (otherwise wait until it does) */
+		if ((mval[0] != prevmval[0]) || (mval[1] != prevmval[1])) {
+			/* try to add point */
+			ok= gp_stroke_addpoint(&p, mval, pressure);
+			
+			/* handle errors while adding point */
+			if ((ok == GP_STROKEADD_FULL) || (ok == GP_STROKEADD_OVERFLOW)) {
+				/* finish off old stroke */
+				gp_paint_strokeend(&p);
+				
+				/* start a new stroke, starting from previous point */
+				gp_stroke_addpoint(&p, prevmval, opressure);
+				ok= gp_stroke_addpoint(&p, mval, pressure);
+			}
+			else if (ok == GP_STROKEADD_INVALID) {
+				/* the painting operation cannot continue... */
+				error("Cannot paint stroke");
+				p.status = GP_STATUS_ERROR;
+				
+				if (G.f & G_DEBUG) 
+					printf("Error: Grease-Pencil Paint - Add Point Invalid \n");
+				break;
+			}
+			force_draw(0);
+			
+			prevmval[0]= mval[0];
+			prevmval[1]= mval[1];
+			opressure= pressure;
+		}
+		else
+			BIF_wait_for_statechange();
+		
+		/* do mouse checking at the end, so don't check twice, and potentially
+		 * miss a short tap 
+		 */
+	} while (get_mbut() & mousebutton);
+	
+	/* clear edit flags */
+	G.f &= ~G_GREASEPENCIL;
+	
+	/* restore cursor to indicate end of drawing */
+	setcursor_space(p.sa->spacetype, CURSOR_STD);
+	
+	/* check size of buffer before cleanup, to determine if anything happened here */
+	ok= p.gpd->sbuffer_size;
+	
+	/* cleanup */
+	gp_paint_cleanup(&p);
+	gp_session_cleanup(&p);
+	
+	/* done! return if a stroke was successfully added */
+	return ok;
+}
+
+
+/* All event (loops) handling checking if stroke drawing should be initiated
+ * should call this function.
+ */
+short gpencil_do_paint (ScrArea *sa)
+{
+	bGPdata *gpd = gpencil_data_getactive(sa);
+	short mousebutton = L_MOUSE; /* for now, this is always on L_MOUSE*/
+	short retval= 0;
+	
+	/* check if possible to do painting */
+	if (gpd == NULL) 
+		return 0;
+	
+	/* currently, we will only paint if:
+	 * 	1. draw-mode on gpd is set (for accessibility reasons)
+	 *		(single 'dots' are only available via this method)
+	 *	2. if shift-modifier is held + lmb -> 'quick paint'
+	 */
+	if (gpd->flag & GP_DATA_EDITPAINT) {
+		/* try to paint */
+		retval = gpencil_paint(mousebutton);
+	}
+	else if (G.qual == LR_SHIFTKEY) {
+		/* try to paint */
+		retval = gpencil_paint(mousebutton);
+	}
+	
+	/* return result of trying to paint */
+	return retval;
+}
+
+/* ************************************************** */
diff --git a/source/blender/src/header_action.c b/source/blender/src/header_action.c
index 9c7046c5111..50d343ca470 100644
--- a/source/blender/src/header_action.c
+++ b/source/blender/src/header_action.c
@@ -50,8 +50,11 @@
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
 
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
 #include "BIF_editaction.h"
 #include "BIF_interface.h"
+#include "BIF_language.h"
 #include "BIF_poseobject.h"
 #include "BIF_resources.h"
 #include "BIF_screen.h"
@@ -76,6 +79,7 @@
 #include "blendef.h"
 #include "mydevice.h"
 
+/* ------------------------------- */
 /* enums declaring constants that are used as menu event codes  */
 
 enum {
@@ -212,6 +216,16 @@ enum {
 	ACTMENU_MARKERS_LOCALMOVE
 };
 
+/* ------------------------------- */
+/* macros for easier state testing (only for use here) */
+
+/* test if active action editor is showing any markers */
+#define G_SACTION_HASMARKERS \
+	((G.saction->action && G.saction->action->markers.first) \
+	 || (G.scene->markers.first))
+
+/* ------------------------------- */
+
 void do_action_buttons(unsigned short event)
 {
 	Object *ob= OBACT;
@@ -398,32 +412,41 @@ static uiBlock *action_viewmenu(void *arg_unused)
 	
 	uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
 	
-	uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_SLIDERS)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
-					 "Show Sliders|", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
-					 ACTMENU_VIEW_SLIDERS, "");
-					 
-	uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOHIDE)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
-					 "Show Hidden Channels|", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
-					 ACTMENU_VIEW_NOHIDE, "");
-					 
-	uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NODRAWGCOLORS)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
-					 "Use Group Colors|", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
-					 ACTMENU_VIEW_GCOLORS, "");
-					 
-		// this option may get removed in future
-	uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_HORIZOPTIMISEON)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
-					 "Cull Out-of-View Keys (Time)|", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
-					 ACTMENU_VIEW_HORIZOPTIMISE, "");
+	if (G.saction->mode == SACTCONT_GPENCIL) {
+			// this option may get removed in future
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_HORIZOPTIMISEON)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
+						 "Cull Out-of-View Keys (Time)|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_HORIZOPTIMISE, "");
+	}
+	else {
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_SLIDERS)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
+						 "Show Sliders|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_SLIDERS, "");
+						 
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOHIDE)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
+						 "Show Hidden Channels|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_NOHIDE, "");
+						 
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NODRAWGCOLORS)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
+						 "Use Group Colors|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_GCOLORS, "");
+						 
+			// this option may get removed in future
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_HORIZOPTIMISEON)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
+						 "Cull Out-of-View Keys (Time)|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_HORIZOPTIMISE, "");
+		
+		uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOTRANSKEYCULL)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
+						 "AutoMerge Keyframes|", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, 
+						 ACTMENU_VIEW_TRANSDELDUPS, "");
+	}	
 	
-	uiDefIconTextBut(block, BUTM, 1, (G.saction->flag & SACTION_NOTRANSKEYCULL)?ICON_CHECKBOX_DEHLT:ICON_CHECKBOX_HLT, 
-					 "AutoMerge Keyframes|", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
-					 ACTMENU_VIEW_TRANSDELDUPS, "");
-			
 		
 	uiDefIconTextBut(block, BUTM, 1, (G.v2d->flag & V2D_VIEWLOCK)?ICON_CHECKBOX_HLT:ICON_CHECKBOX_DEHLT, 
 					 "Lock Time to Other Windows|", 0, yco-=20, 
@@ -476,7 +499,7 @@ static uiBlock *action_viewmenu(void *arg_unused)
 					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
 					 ACTMENU_VIEW_PREVRANGECLEAR, "");
 		
-	if (G.saction->action) {
+	if ((G.saction->mode == SACTCONT_ACTION) && (G.saction->action)) {
 		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
 					 "Preview Range from Action Length|Ctrl Alt P", 0, yco-=20, 
 					 menuwidth, 19, NULL, 0.0, 0.0, 1, 
@@ -550,13 +573,15 @@ static uiBlock *action_selectmenu_columnmenu(void *arg_unused)
 	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
 					 "On Current Frame|Ctrl K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0,  
 					 ACTMENU_SEL_COLUMN_CFRA, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "On Selected Markers|Shift K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_COLUMN_MARKERSCOLUMN, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Between Selected Markers|Alt K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_COLUMN_MARKERSBETWEEN, "");
 	
+	if (G_SACTION_HASMARKERS) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "On Selected Markers|Shift K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_COLUMN_MARKERSCOLUMN, "");
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Between Selected Markers|Alt K", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_COLUMN_MARKERSBETWEEN, "");
+	}
 	
 	uiBlockSetDirection(block, UI_RIGHT);
 	uiTextBoundsBlock(block, 60);
@@ -659,14 +684,18 @@ static uiBlock *action_selectmenu(void *arg_unused)
 					 "Border Select Keys|B", 0, yco-=20, 
 					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
 					 ACTMENU_SEL_BORDER, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Border Select Channels|B", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_BORDERC, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Border Select Markers|Ctrl B", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_BORDERM, "");
+	if (G_SACTION_HASMARKERS) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Border Select Markers|Ctrl B", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_BORDERM, "");
+	}
+	if (G.saction->mode != SACTCONT_SHAPEKEY) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Border Select Channels|B", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_BORDERC, "");
+	}
 					 
 	uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
 			 menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
@@ -675,14 +704,18 @@ static uiBlock *action_selectmenu(void *arg_unused)
 					 "Select/Deselect All Keys|A", 0, yco-=20, 
 					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
 					 ACTMENU_SEL_ALL_KEYS, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Select/Deselect All Markers|Ctrl A", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_ALL_MARKERS, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Select/Deselect All Channels|A", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_ALL_CHAN, "");
+	if (G_SACTION_HASMARKERS) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Select/Deselect All Markers|Ctrl A", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_ALL_MARKERS, "");
+	}
+	if (G.saction->mode != SACTCONT_SHAPEKEY) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Select/Deselect All Channels|A", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_ALL_CHAN, "");
+	}
 					 
 	uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
 			 menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
@@ -691,14 +724,18 @@ static uiBlock *action_selectmenu(void *arg_unused)
 					 "Inverse Keys|Ctrl I", 0, yco-=20, 
 					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
 					 ACTMENU_SEL_INVERSE_KEYS, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Inverse Markers|Ctrl Shift I", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_INVERSE_MARKERS, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
-					 "Inverse All Channels|Ctrl I", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 0, 
-					 ACTMENU_SEL_INVERSE_CHANNELS, "");
+	if (G_SACTION_HASMARKERS) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Inverse Markers|Ctrl Shift I", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_INVERSE_MARKERS, "");
+	}
+	if (G.saction->mode != SACTCONT_SHAPEKEY) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+						 "Inverse All Channels|Ctrl I", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 0, 
+						 ACTMENU_SEL_INVERSE_CHANNELS, "");
+	}
 		
 	uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
 			 menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
@@ -971,6 +1008,40 @@ static uiBlock *action_channelmenu(void *arg_unused)
 	return block;
 }
 
+/* note: uses do_action_channelmenu too... */
+static uiBlock *action_gplayermenu(void *arg_unused)
+{
+	uiBlock *block;
+	short yco= 0, menuwidth=120;
+
+	block= uiNewBlock(&curarea->uiblocks, "action_gplayermenu", 
+					  UI_EMBOSSP, UI_HELV, curarea->headwin);
+	uiBlockSetButmFunc(block, do_action_channelmenu, NULL);
+	
+	uiDefIconTextBlockBut(block, action_channelmenu_settingsmenu, 
+						  NULL, ICON_RIGHTARROW_THIN, 
+						  "Settings", 0, yco-=20, 120, 20, "");	
+	
+	uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
+					menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
+	
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+			"Delete|X", 0, yco-=20,
+			menuwidth, 19, NULL, 0.0, 0.0, 0, ACTMENU_CHANNELS_DELETE, "");
+	
+	if (curarea->headertype==HEADERTOP) {
+		uiBlockSetDirection(block, UI_DOWN);
+	}
+	else {
+		uiBlockSetDirection(block, UI_TOP);
+		uiBlockFlipOrder(block);
+	}
+
+	uiTextBoundsBlock(block, 50);
+
+	return block;
+}
+
 static void do_action_keymenu_transformmenu(void *arg, int event)
 {	
 	switch (event)
@@ -1400,6 +1471,51 @@ static uiBlock *action_keymenu(void *arg_unused)
 	return block;
 }
 
+/* note: uses do_action_keymenu too! */
+static uiBlock *action_framemenu(void *arg_unused)
+{
+	uiBlock *block;
+	short yco= 0, menuwidth=120;
+
+	block= uiNewBlock(&curarea->uiblocks, "action_framemenu", 
+					  UI_EMBOSSP, UI_HELV, curarea->headwin);
+	uiBlockSetButmFunc(block, do_action_keymenu, NULL);
+	
+	uiDefIconTextBlockBut(block, action_keymenu_transformmenu, 
+						  NULL, ICON_RIGHTARROW_THIN, "Transform", 0, yco-=20, 120, 20, "");
+	
+	uiDefIconTextBlockBut(block, action_keymenu_snapmenu, 
+						  NULL, ICON_RIGHTARROW_THIN, "Snap", 0, yco-=20, 120, 20, "");
+	
+	uiDefIconTextBlockBut(block, action_keymenu_mirrormenu, 
+						  NULL, ICON_RIGHTARROW_THIN, "Mirror", 0, yco-=20, 120, 20, "");
+	
+	uiDefBut(block, SEPR, 0, "", 0, yco-=6, 
+			 menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
+					
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+					"Duplicate|Shift D", 0, yco-=20, 
+					menuwidth, 19, NULL, 0.0, 0.0, 0, 
+					ACTMENU_KEY_DUPLICATE, "");
+	
+	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
+					"Delete|X", 0, yco-=20, 
+					menuwidth, 19, NULL, 0.0, 0.0, 0, 
+					ACTMENU_KEY_DELETE, "");
+	
+	if(curarea->headertype==HEADERTOP) {
+		uiBlockSetDirection(block, UI_DOWN);
+	}
+	else {
+		uiBlockSetDirection(block, UI_TOP);
+		uiBlockFlipOrder(block);
+	}
+
+	uiTextBoundsBlock(block, 50);
+
+	return block;
+}
+
 static void do_action_markermenu(void *arg, int event)
 {	
 	switch(event)
@@ -1461,17 +1577,19 @@ static uiBlock *action_markermenu(void *arg_unused)
 					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_NAME, "");
 	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Grab/Move Marker|Ctrl G", 0, yco-=20,
 					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_MOVE, "");
-					 
-	uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
-	
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Add Pose Marker|Shift L", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALADD, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Rename Pose Marker|Ctrl Shift L", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALRENAME, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Delete Pose Marker|Alt L", 0, yco-=20,
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALDELETE, "");
-	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Grab/Move Pose Marker|Ctrl L", 0, yco-=20, 
-					 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALMOVE, "");
+		
+	if (G.saction->mode == SACTCONT_ACTION) {
+		uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
+		
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Add Pose Marker|Shift L", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALADD, "");
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Rename Pose Marker|Ctrl Shift L", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALRENAME, "");
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Delete Pose Marker|Alt L", 0, yco-=20,
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALDELETE, "");
+		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Grab/Move Pose Marker|Ctrl L", 0, yco-=20, 
+						 menuwidth, 19, NULL, 0.0, 0.0, 1, ACTMENU_MARKERS_LOCALMOVE, "");
+	}
 	
 	if(curarea->headertype==HEADERTOP) {
 		uiBlockSetDirection(block, UI_DOWN);
@@ -1498,6 +1616,7 @@ void action_buttons(void)
 		return;
 
 	/* copied from drawactionspace.... */
+	// FIXME: do for gpencil too?
 	if (!G.saction->pin) {
 		if (OBACT)
 			G.saction->action = OBACT->action;
@@ -1558,68 +1677,112 @@ void action_buttons(void)
 					  "Select", xco, -2, xmax-3, 24, "");
 		xco+= xmax;
 		
-		if (G.saction->action) {
+		if ((G.saction->action) && (G.saction->mode==SACTCONT_ACTION)) {
 			xmax= GetButStringLength("Channel");
 			uiDefPulldownBut(block, action_channelmenu, NULL, 
 						  "Channel", xco, -2, xmax-3, 24, "");
 			xco+= xmax;
 		}
+		else if ((G.saction->gpd) && (G.saction->mode==SACTCONT_GPENCIL)) {
+			xmax= GetButStringLength("Channel");
+			uiDefPulldownBut(block, action_gplayermenu, NULL, 
+						  "Channel", xco, -2, xmax-3, 24, "");
+			xco+= xmax;
+		}
 		
 		xmax= GetButStringLength("Marker");
 		uiDefPulldownBut(block, action_markermenu, NULL, 
 					  "Marker", xco, -2, xmax-3, 24, "");
 		xco+= xmax;
 		
-		xmax= GetButStringLength("Key");
-		uiDefPulldownBut(block, action_keymenu, NULL, 
-					  "Key", xco, -2, xmax-3, 24, "");
-		xco+= xmax;
+		if (G.saction->mode == SACTCONT_GPENCIL) {
+			xmax= GetButStringLength("Frame");
+			uiDefPulldownBut(block, action_framemenu, NULL, 
+						  "Frame", xco, -2, xmax-3, 24, "");
+			xco+= xmax;
+
+		}
+		else {
+			xmax= GetButStringLength("Key");
+			uiDefPulldownBut(block, action_keymenu, NULL, 
+						  "Key", xco, -2, xmax-3, 24, "");
+			xco+= xmax;
+		}
 	}
 
 	uiBlockSetEmboss(block, UI_EMBOSS);
 	
-	/* NAME ETC */
-	ob= OBACT;
-	from = (ID *)ob;
-
-	xco= std_libbuttons(block, xco, 0, B_ACTPIN, &G.saction->pin, 
-						B_ACTIONBROWSE, ID_AC, 0, (ID*)G.saction->action, 
-						from, &(G.saction->actnr), B_ACTALONE, 
-						B_ACTLOCAL, B_ACTIONDELETE, 0, B_KEEPDATA);	
+	/* MODE SELECTOR */
+	uiDefButC(block, MENU, B_REDR, 
+			"Editor Mode %t|Action Editor %x0|ShapeKey Editor %x1|Grease Pencil %x2", 
+			xco,0,90,YIC, &(G.saction->mode), 0, 1, 0, 0, 
+			"Editing modes for this editor");
 
-	uiClearButLock();
-
-	xco += 8;
 	
-	/* COPY PASTE */
-	uiBlockBeginAlign(block);
-	if (curarea->headertype==HEADERTOP) {
-		uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYUP,	xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
-		uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEUP,	xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
-	}
-	else {
-		uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYDOWN,	xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
-		uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEDOWN,	xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
-	}
-	uiBlockEndAlign(block);
-	xco += (XIC + 8);
+	xco += (90 + 8);
 	
-	/* draw AUTOSNAP */
-	if (G.saction->flag & SACTION_DRAWTIME) {
-		uiDefButS(block, MENU, B_REDR,
-				"Auto-Snap Keyframes %t|No Snap %x0|Second Step %x1|Nearest Second %x2|Nearest Marker %x3", 
-				xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
-				"Auto-snapping mode for keyframes when transforming");
+	/* MODE-DEPENDENT DRAWING */
+	if (G.saction->mode == SACTCONT_GPENCIL) {
+		char gp_name[64];
+		
+		/* pin button */
+		uiDefIconButS(block, ICONTOG, B_ACTPIN, ICON_PIN_DEHLT, xco,0,XIC,YIC, &G.saction->pin, 0, 0, 0, 0, "Keeps this view displaying the current data regardless of what Grease Pencil set is active");
+		xco += (XIC + 5);
+		
+		/* just a simple string to help identify if any content */
+		glRasterPos2f((float)xco, 5.0);
+		BIF_RasterPos((float)xco, 5.0);	// stupid texture fonts
+		BIF_ThemeColor(TH_TEXT);
+		
+		sprintf(gp_name, (G.saction->gpd)?"Grease Pencil Data":"<None>");
+		xmax= GetButStringLength(gp_name);
+		BIF_DrawString(uiBlockGetCurFont(block), gp_name, (U.transopts & USER_TR_BUTTONS));
+		xco += xmax;
 	}
 	else {
-		uiDefButS(block, MENU, B_REDR, 
-				"Auto-Snap Keyframes %t|No Snap %x0|Frame Step %x1|Nearest Frame %x2|Nearest Marker %x3", 
-				xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
-				"Auto-snapping mode for keyframes when transforming");
+		/* NAME ETC */
+		ob= OBACT;
+		from = (ID *)ob;
+		
+		xco= std_libbuttons(block, xco, 0, B_ACTPIN, &G.saction->pin, 
+							B_ACTIONBROWSE, ID_AC, 0, (ID*)G.saction->action, 
+							from, &(G.saction->actnr), B_ACTALONE, 
+							B_ACTLOCAL, B_ACTIONDELETE, 0, B_KEEPDATA);	
+		
+		uiClearButLock();
+		
+		xco += 8;
+		
+		/* COPY PASTE */
+		uiBlockBeginAlign(block);
+		if (curarea->headertype==HEADERTOP) {
+			uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYUP,	xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
+			uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEUP,	xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
+		}
+		else {
+			uiDefIconBut(block, BUT, B_ACTCOPYKEYS, ICON_COPYDOWN,	xco,0,XIC,YIC, 0, 0, 0, 0, 0, "Copies the selected keyframes from the selected channel(s) to the buffer");
+			uiDefIconBut(block, BUT, B_ACTPASTEKEYS, ICON_PASTEDOWN,	xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Pastes the keyframes from the buffer");
+		}
+		uiBlockEndAlign(block);
+		xco += (XIC + 8);
+		
+		/* draw AUTOSNAP */
+		if (G.saction->flag & SACTION_DRAWTIME) {
+			uiDefButC(block, MENU, B_REDR,
+					"Auto-Snap Keyframes %t|No Snap %x0|Second Step %x1|Nearest Second %x2|Nearest Marker %x3", 
+					xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
+					"Auto-snapping mode for keyframes when transforming");
+		}
+		else {
+			uiDefButC(block, MENU, B_REDR, 
+					"Auto-Snap Keyframes %t|No Snap %x0|Frame Step %x1|Nearest Frame %x2|Nearest Marker %x3", 
+					xco,0,70,YIC, &(G.saction->autosnap), 0, 1, 0, 0, 
+					"Auto-snapping mode for keyframes when transforming");
+		}
+		
+		xco += (70 + 8);
 	}
 	
-	xco += (70 + 8);
-	
 	/* draw LOCK */
 	uiDefIconButS(block, ICONTOG, 1, ICON_UNLOCKED,	xco, 0, XIC, YIC, 
 				  &(G.saction->lock), 0, 0, 0, 0, 
diff --git a/source/blender/src/header_node.c b/source/blender/src/header_node.c
index ec6bbc9044c..4c7b4aa80bc 100644
--- a/source/blender/src/header_node.c
+++ b/source/blender/src/header_node.c
@@ -110,12 +110,16 @@ static void do_node_viewmenu(void *arg, int event)
 		case 3: /* View all */
 			snode_home(curarea, snode);
 			break;
+		case 4: /* Grease Pencil */
+			add_blockhandler(curarea, NODES_HANDLER_GREASEPENCIL, UI_PNL_UNSTOW);
+		break;
 	}
 	allqueue(REDRAWNODE, 0);
 }
 
 static uiBlock *node_viewmenu(void *arg_unused)
 {
+	SpaceNode *snode= curarea->spacedata.first; 
 	uiBlock *block;
 	short yco= 0, menuwidth=120;
 	
@@ -123,6 +127,12 @@ static uiBlock *node_viewmenu(void *arg_unused)
 					  UI_EMBOSSP, UI_HELV, curarea->headwin);
 	uiBlockSetButmFunc(block, do_node_viewmenu, NULL);
 
+	if (snode->nodetree) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, "Grease Pencil...", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, 4, "");
+		
+		uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
+	}
+	
 	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Zoom In|NumPad +", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, 1, "");
 	uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Zoom Out|NumPad -", 0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 1, 2, "");
 	
diff --git a/source/blender/src/header_seq.c b/source/blender/src/header_seq.c
index 393830a61cf..e5a63b9fe45 100644
--- a/source/blender/src/header_seq.c
+++ b/source/blender/src/header_seq.c
@@ -100,6 +100,9 @@ static void do_seq_viewmenu(void *arg, int event)
 	case 6: /* Draw time/frames */
 		sseq->flag ^= SEQ_DRAWFRAMES;
 		break;
+	case 7: /* Grease Pencil */
+		add_blockhandler(curarea, SEQ_HANDLER_GREASEPENCIL, UI_PNL_UNSTOW);
+		break;
 	}
 }
 
@@ -111,7 +114,15 @@ static uiBlock *seq_viewmenu(void *arg_unused)
 
 	block= uiNewBlock(&curarea->uiblocks, "seq_viewmenu", UI_EMBOSSP, UI_HELV, curarea->headwin);
 	uiBlockSetButmFunc(block, do_seq_viewmenu, NULL);
-
+	
+	if (sseq->mainb) {
+		uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, 
+				 "Grease Pencil...", 0, yco-=20,
+				 menuwidth, 19, NULL, 0.0, 0.0, 1, 7, "");
+				 
+		uiDefBut(block, SEPR, 0, "",        0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
+	}
+	
 	if (sseq->mainb == 0) {
 		uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, 
 				 "Play Back Animation "
diff --git a/source/blender/src/header_view3d.c b/source/blender/src/header_view3d.c
index 0f3a46c8a8c..71bf0cd9bd4 100644
--- a/source/blender/src/header_view3d.c
+++ b/source/blender/src/header_view3d.c
@@ -601,6 +601,9 @@ static void do_view3d_viewmenu(void *arg, int event)
 		break;
 	case 20: /* Transform  Space Panel */
 		add_blockhandler(curarea, VIEW3D_HANDLER_TRANSFORM, UI_PNL_UNSTOW);
+		break;	
+	case 21: /* Grease Pencil */
+		add_blockhandler(curarea, VIEW3D_HANDLER_GREASEPENCIL, UI_PNL_UNSTOW);
 		break;		
 	}
 	allqueue(REDRAWVIEW3D, 1);
@@ -619,6 +622,7 @@ static uiBlock *view3d_viewmenu(void *arg_unused)
 	uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, "Render Preview...|Shift P",	0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 18, "");
 	uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, "View Properties...",	0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 16, "");
 	uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, "Background Image...",	0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 15, "");
+	uiDefIconTextBut(block, BUTM, 1, ICON_MENU_PANEL, "Grease Pencil...",	0, yco-=20, menuwidth, 19, NULL, 0.0, 0.0, 0, 21, "");
 	
 	uiDefBut(block, SEPR, 0, "",					0, yco-=6, menuwidth, 6, NULL, 0.0, 0.0, 0, 0, "");
 	
diff --git a/source/blender/src/interface.c b/source/blender/src/interface.c
index 4fbf92d646e..ba8649eaa86 100644
--- a/source/blender/src/interface.c
+++ b/source/blender/src/interface.c
@@ -618,6 +618,9 @@ void uiBoundsBlock(uiBlock *block, int addval)
 	uiBut *bt;
 	int xof;
 	
+	if(block==NULL)
+		return;
+	
 	if(block->buttons.first==NULL) {
 		if(block->panel) {
 			block->minx= 0.0; block->maxx= block->panel->sizex;
@@ -5405,7 +5408,9 @@ uiBlock *uiNewBlock(ListBase *lb, char *name, short dt, short font, short win)
 		int getsizex, getsizey;
 
 		bwin_getsize(win, &getsizex, &getsizey);
-		block->aspect= 2.0/( (getsizex)*block->winmat[0][0]);
+		/* TODO - investigate why block->winmat[0][0] is negative
+		 * in the image view when viewRedrawForce is called */
+		block->aspect= 2.0/fabs( (getsizex)*block->winmat[0][0]);
 	}
 
 	uiSetCurFont(block, font);
diff --git a/source/blender/src/poselib.c b/source/blender/src/poselib.c
index 2d8b0c81175..fb2bfe5b605 100644
--- a/source/blender/src/poselib.c
+++ b/source/blender/src/poselib.c
@@ -756,6 +756,13 @@ static void poselib_keytag_pose (tPoseLib_PreviewData *pld)
  */
 static void poselib_preview_get_next (tPoseLib_PreviewData *pld, int step)
 {
+	/* check if we no longer have search-string, but don't have any marker */
+	if (pld->marker == NULL) {
+		if ((step) && (pld->searchstr[0] == 0))
+			pld->marker= pld->act->markers.first;
+	}	
+	
+	/* the following operations assume that there is a starting point and direction */
 	if ((pld->marker) && (step)) {
 		/* search-string dictates a special approach */
 		if (pld->searchstr[0]) {
@@ -1262,9 +1269,14 @@ void poselib_preview_poses (Object *ob, short apply_active)
 					/* get search-string */
 					index= pld.search_cursor;
 					
-					memcpy(&tempstr[0], &pld.searchstr[0], index);
-					tempstr[index]= '|';
-					memcpy(&tempstr[index+1], &pld.searchstr[index], 64-index);
+					if (IN_RANGE(index, 0, 64)) {
+						memcpy(&tempstr[0], &pld.searchstr[0], index);
+						tempstr[index]= '|';
+						memcpy(&tempstr[index+1], &pld.searchstr[index], 64-index);
+					}
+					else {
+						strncpy(tempstr, pld.searchstr, 64);
+					}
 					
 					/* get marker name */
 					if (pld.marker)
diff --git a/source/blender/src/resources.c b/source/blender/src/resources.c
index 046d14c990d..f47f14a605c 100644
--- a/source/blender/src/resources.c
+++ b/source/blender/src/resources.c
@@ -52,6 +52,7 @@
 #include "BIF_interface_icons.h"
 
 #include "BLI_blenlib.h"
+#include "BLI_dynstr.h"
 #include "blendef.h"	// CLAMP
 #include "datatoc.h"
 
@@ -784,6 +785,33 @@ char *BIF_ThemeColorsPup(int spacetype)
 	return cp;
 }
 
+char *BIF_ThemeColorSetsPup (short inc_custom)
+{
+	DynStr *pupds= BLI_dynstr_new();
+	char *str;
+	char buf[48];
+	int i;
+	
+	/* add title first (and the "default" entry) */
+	BLI_dynstr_append(pupds, "Bone Color Set%t|Default Colors%x0|");
+	
+	/* loop through set indices, adding them */
+	for (i=1; i<21; i++) {
+		sprintf(buf, "%d - Theme Color Set%%x%d|", i, i);
+		BLI_dynstr_append(pupds, buf);
+	}
+	
+	/* add the 'custom' entry */
+	if (inc_custom)
+		BLI_dynstr_append(pupds, "Custom Set %x-1");
+	
+	/* convert to normal MEM_malloc'd string */
+	str= BLI_dynstr_get_cstring(pupds);
+	BLI_dynstr_free(pupds);
+	
+	return str;
+}
+
 void BIF_SetTheme(ScrArea *sa)
 {
 	if(sa==NULL) {	// called for safety, when delete themes
diff --git a/source/blender/src/space.c b/source/blender/src/space.c
index 3b8bb4c3929..92efb477095 100644
--- a/source/blender/src/space.c
+++ b/source/blender/src/space.c
@@ -56,6 +56,7 @@
 #include "DNA_armature_types.h"
 #include "DNA_curve_types.h"
 #include "DNA_group_types.h" /* used for select_same_group */
+#include "DNA_gpencil_types.h"
 #include "DNA_image_types.h"
 #include "DNA_ipo_types.h"
 #include "DNA_mesh_types.h"
@@ -159,6 +160,7 @@
 #include "BDR_imagepaint.h"
 #include "BDR_sculptmode.h"
 #include "BDR_unwrapper.h"
+#include "BDR_gpencil.h"
 
 #include "BLO_readfile.h" /* for BLO_blendhandle_close */
 
@@ -1193,13 +1195,17 @@ static void winqreadview3dspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 		
 		if(event==UI_BUT_EVENT) do_butspace(val); /* temporal, view3d deserves own queue? */
 		
-		/* we consider manipulator a button, defaulting to leftmouse */
+		/* - we consider manipulator a button, defaulting to leftmouse 
+		 * - grease-pencil also defaults to leftmouse
+		 */
 		if(event==LEFTMOUSE) {
 			/* run any view3d event handler script links */
-			if (event && sa->scriptlink.totscript)
+			if (event && sa->scriptlink.totscript) {
 				if (BPY_do_spacehandlers(sa, event, SPACEHANDLER_VIEW3D_EVENT))
 					return; /* return if event was processed (swallowed) by handler(s) */
-
+			}
+			
+			if(gpencil_do_paint(sa)) return;
 			if(BIF_do_manipulator(sa)) return;
 		}
 		
@@ -1207,7 +1213,7 @@ static void winqreadview3dspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 		if (U.flag & USER_LMOUSESELECT) {
 			/* only swap mouse button for selection, in modes where it is relevant.
 			 * painting/sculpting stays on LEFTMOUSE */
-			if (   !((G.f & G_SCULPTMODE) || (G.f & G_WEIGHTPAINT) ||
+			if (   !((G.f & G_SCULPTMODE) || (G.f & G_WEIGHTPAINT) || (G.f & G_GREASEPENCIL) ||
 				(G.f & G_VERTEXPAINT) || (G.f & G_TEXTUREPAINT) || (G.f & G_PARTICLEEDIT)) ||
 				(G.obedit) )
 			{			
@@ -1945,7 +1951,7 @@ static void winqreadview3dspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 						adduplicate(0, 0);
 				}
 				else if(G.qual==LR_CTRLKEY) {
-					imagestodisplist();
+					imagestodisplist(); // removed
 				}
 				else if((G.qual==0)){
 					pupval= pupmenu("Draw mode%t|BoundBox %x1|Wire %x2|OpenGL Solid %x3|Shaded Solid %x4|Textured Solid %x5");
@@ -4816,6 +4822,11 @@ static void winqreadseqspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 	if(val) {
 		if( uiDoBlocks(&curarea->uiblocks, event, 1)!=UI_NOTHING ) event= 0;
 		
+		/* grease-pencil defaults to leftmouse */
+		if(event==LEFTMOUSE) {
+			if(gpencil_do_paint(sa)) return;
+		}
+		
 		/* swap mouse buttons based on user preference */
 		if (U.flag & USER_LMOUSESELECT) {
 			if (event == LEFTMOUSE) {
@@ -4829,11 +4840,11 @@ static void winqreadseqspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 		
 		switch(event) {
 		case LEFTMOUSE:
-			if(sseq->mainb || view2dmove(event)==0) {
+			if(sseq->mainb==0 && view2dmove(event)==0) {
 				
 				first= 1;		
 				set_special_seq_update(1);
-
+				
 				do {
 					getmouseco_areawin(mval);
 					areamouseco_to_ipoco(v2d, mval, &dx, &dy);
@@ -4844,9 +4855,9 @@ static void winqreadseqspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
 					
 					if( cfra!=CFRA || first ) {
 						first= 0;
-				
+						
 						CFRA= cfra;
-						force_draw(0);
+						force_draw_all(0);
 						update_for_newframe();	/* for audio scrubbing */						
 					}
 					else PIL_sleep_ms(30);
@@ -6241,6 +6252,7 @@ void freespacelist(ScrArea *sa)
 				if(vd->bgpic->ima) vd->bgpic->ima->id.us--;
 				MEM_freeN(vd->bgpic);
 			}
+			if(vd->gpd) free_gpencil_data(vd->gpd);
 			if(vd->localvd) MEM_freeN(vd->localvd);
 			if(vd->clipbb) MEM_freeN(vd->clipbb);
 			if(vd->depths) {
@@ -6284,7 +6296,12 @@ void freespacelist(ScrArea *sa)
 				curvemapping_free(sima->cumap);
 		}
 		else if(sl->spacetype==SPACE_NODE) {
-/*			SpaceNode *snode= (SpaceNode *)sl; */
+			SpaceNode *snode= (SpaceNode *)sl;
+			if(snode->gpd) free_gpencil_data(snode->gpd);
+		}
+		else if(sl->spacetype==SPACE_SEQ) {
+			SpaceSeq *sseq= (SpaceSeq *)sl;
+			if(sseq->gpd) free_gpencil_data(sseq->gpd);
 		}
 	}
 
@@ -6314,6 +6331,7 @@ void duplicatespacelist(ScrArea *newarea, ListBase *lb1, ListBase *lb2)
 			BIF_view3d_previewrender_free(v3d);
 			v3d->depths= NULL;
 			v3d->retopo_view_data= NULL;
+			v3d->gpd= gpencil_data_duplicate(v3d->gpd);
 		}
 		else if(sl->spacetype==SPACE_OOPS) {
 			SpaceOops *so= (SpaceOops *)sl;
@@ -6333,11 +6351,16 @@ void duplicatespacelist(ScrArea *newarea, ListBase *lb1, ListBase *lb2)
 		else if(sl->spacetype==SPACE_NODE) {
 			SpaceNode *snode= (SpaceNode *)sl;
 			snode->nodetree= NULL;
+			snode->gpd= gpencil_data_duplicate(snode->gpd);
 		}
 		else if(sl->spacetype==SPACE_SCRIPT) {
 			SpaceScript *sc = ( SpaceScript * ) sl;
 			sc->but_refs = NULL;
 		}
+		else if(sl->spacetype==SPACE_SEQ) {
+			SpaceSeq *sseq= (SpaceSeq *)sl;
+			sseq->gpd= gpencil_data_duplicate(sseq->gpd);
+		}
 		sl= sl->next;
 	}
 	
diff --git a/source/blender/src/transform_conversions.c b/source/blender/src/transform_conversions.c
index 10e49cdd218..706b079432c 100644
--- a/source/blender/src/transform_conversions.c
+++ b/source/blender/src/transform_conversions.c
@@ -70,6 +70,7 @@
 #include "DNA_vfont_types.h"
 #include "DNA_constraint_types.h"
 #include "DNA_listBase.h"
+#include "DNA_gpencil_types.h"
 
 #include "BKE_action.h"
 #include "BKE_armature.h"
@@ -125,6 +126,7 @@
 
 #include "BDR_drawaction.h"		// list of keyframes in action
 #include "BDR_editobject.h"		// reset_slowparents()
+#include "BDR_gpencil.h"
 #include "BDR_unwrapper.h"
 
 #include "BLI_arithb.h"
@@ -2474,6 +2476,96 @@ void flushTransIpoData(TransInfo *t)
 
 /* ********************* ACTION/NLA EDITOR ****************** */
 
+/* Called by special_aftertrans_update to make sure selected gp-frames replace
+ * any other gp-frames which may reside on that frame (that are not selected).
+ * It also makes sure gp-frames are still stored in chronological order after
+ * transform.
+ */
+static void posttrans_gpd_clean (bGPdata *gpd)
+{
+	bGPDlayer *gpl;
+	
+	for (gpl= gpd->layers.first; gpl; gpl= gpl->next) {
+		ListBase sel_buffer = {NULL, NULL};
+		bGPDframe *gpf, *gpfn;
+		bGPDframe *gfs, *gfsn;
+		
+		/* loop 1: loop through and isolate selected gp-frames to buffer 
+		 * (these need to be sorted as they are isolated)
+		 */
+		for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
+			gpfn= gpf->next;
+			
+			if (gpf->flag & GP_FRAME_SELECT) {
+				BLI_remlink(&gpl->frames, gpf);
+				
+				/* find place to add them in buffer
+				 * - go backwards as most frames will still be in order,
+				 *   so doing it this way will be faster 
+				 */
+				for (gfs= sel_buffer.last; gfs; gfs= gfs->prev) {
+					/* if current (gpf) occurs after this one in buffer, add! */
+					if (gfs->framenum < gpf->framenum) {
+						BLI_insertlinkafter(&sel_buffer, gfs, gpf);
+						break;
+					}
+				}
+				if (gfs == NULL)
+					BLI_addhead(&sel_buffer, gpf);
+			}
+		}
+		
+		/* error checking: it is unlikely, but may be possible to have none selected */
+		if (sel_buffer.first == NULL)
+			continue;
+		
+		/* if all were selected (i.e. gpl->frames is empty), then just transfer sel-buf over */
+		if (gpl->frames.first == NULL) {
+			gpl->frames.first= sel_buffer.first;
+			gpl->frames.last= sel_buffer.last;
+			
+			continue;
+		}
+		
+		/* loop 2: remove duplicates of frames in buffers */
+		//gfs= sel_buffer.first;
+		//gfsn= gfs->next;
+		
+		for (gpf= gpl->frames.first; gpf && sel_buffer.first; gpf= gpfn) {
+			gpfn= gpf->next;
+			 
+			/* loop through sel_buffer, emptying stuff from front of buffer if ok */
+			for (gfs= sel_buffer.first; gfs && gpf; gfs= gfsn) {
+				gfsn= gfs->next;
+				
+				/* if this buffer frame needs to go before current, add it! */
+				if (gfs->framenum < gpf->framenum) {
+					/* transfer buffer frame to frames list (before current) */
+					BLI_remlink(&sel_buffer, gfs);
+					BLI_insertlinkbefore(&gpl->frames, gpf, gfs);
+				}
+				/* if this buffer frame is on same frame, replace current with it and stop */
+				else if (gfs->framenum == gpf->framenum) {
+					/* transfer buffer frame to frames list (before current) */
+					BLI_remlink(&sel_buffer, gfs);
+					BLI_insertlinkbefore(&gpl->frames, gpf, gfs);
+					
+					/* get rid of current frame */
+					gpencil_layer_delframe(gpl, gpf);
+				}
+			}
+		}
+		
+		/* if anything is still in buffer, append to end */
+		for (gfs= sel_buffer.first; gfs; gfs= gfsn) {
+			gfsn= gfs->next;
+			
+			BLI_remlink(&sel_buffer, gfs);
+			BLI_addtail(&gpl->frames, gfs);
+		}
+	}
+}
+
 /* Called by special_aftertrans_update to make sure selected keyframes replace
  * any other keyframes which may reside on that frame (that is not selected).
  */
@@ -2698,6 +2790,26 @@ static int count_ipo_keys(Ipo *ipo, char side, float cfra)
 	return count;
 }
 
+/* fully select selected beztriples, but only include if it's on the right side of cfra */
+static int count_gplayer_frames(bGPDlayer *gpl, char side, float cfra)
+{
+	bGPDframe *gpf;
+	int count = 0;
+	
+	if (gpl == NULL)
+		return count;
+	
+	/* only include points that occur on the right side of cfra */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if (gpf->flag & GP_FRAME_SELECT) {
+			if (FrameOnMouseSide(side, gpf->framenum, cfra))
+				count++;
+		}
+	}
+	
+	return count;
+}
+
 /* This function assigns the information to transdata */
 static void TimeToTransData(TransData *td, float *time, Object *ob)
 {
@@ -2751,9 +2863,68 @@ static TransData *IpoToTransData(TransData *td, Ipo *ipo, Object *ob, char side,
 	return td;
 }
 
+/* helper struct for gp-frame transforms (only used here) */
+typedef struct tGPFtransdata {
+	float val;			/* where transdata writes transform */
+	int *sdata;			/* pointer to gpf->framenum */
+} tGPFtransdata;
+
+/* This function helps flush transdata written to tempdata into the gp-frames  */
+void flushTransGPactionData (TransInfo *t)
+{
+	tGPFtransdata *tfd;
+	int i;
+	
+	/* find the first one to start from */
+	if (t->mode == TFM_TIME_SLIDE)
+		tfd= (tGPFtransdata *)( (float *)(t->customData) + 2 );
+	else
+		tfd= (tGPFtransdata *)(t->customData);
+		
+	/* flush data! */
+	for (i = 0; i < t->total; i++, tfd++) {
+		*(tfd->sdata)= (int)floor(tfd->val + 0.5);
+	}	
+}
+
+/* This function advances the address to which td points to, so it must return
+ * the new address so that the next time new transform data is added, it doesn't
+ * overwrite the existing ones...  i.e.   td = GPLayerToTransData(td, ipo, ob, side, cfra);
+ *
+ * The 'side' argument is needed for the extend mode. 'B' = both sides, 'R'/'L' mean only data
+ * on the named side are used. 
+ */
+static int GPLayerToTransData (TransData *td, tGPFtransdata *tfd, bGPDlayer *gpl, short side, float cfra)
+{
+	bGPDframe *gpf;
+	int count= 0;
+	
+	/* check for select frames on right side of current frame */
+	for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
+		if (gpf->flag & GP_FRAME_SELECT) {
+			if (FrameOnMouseSide(side, gpf->framenum, cfra)) {
+				/* memory is calloc'ed, so that should zero everything nicely for us */
+				td->val= &tfd->val;
+				td->ival= gpf->framenum;
+				
+				tfd->val= gpf->framenum;
+				tfd->sdata= &gpf->framenum;
+				
+				/* advance td now */
+				td++;
+				tfd++;
+				count++;
+			}
+		}
+	}
+	
+	return count;
+}
+
 static void createTransActionData(TransInfo *t)
 {
 	TransData *td = NULL;
+	tGPFtransdata *tfd = NULL;
 	Object *ob= NULL;
 	
 	ListBase act_data = {NULL, NULL};
@@ -2771,7 +2942,10 @@ static void createTransActionData(TransInfo *t)
 	if (data == NULL) return;
 	
 	/* filter data */
-	filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
+	if (datatype == ACTCONT_GPENCIL)
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT);
+	else
+		filter= (ACTFILTER_VISIBLE | ACTFILTER_FOREDIT | ACTFILTER_IPOKEYS);
 	actdata_filter(&act_data, filter, data, datatype);
 	
 	/* is the action scaled? if so, the it should belong to the active object */
@@ -2800,8 +2974,12 @@ static void createTransActionData(TransInfo *t)
 		cfra = CFRA;
 	
 	/* loop 1: fully select ipo-keys and count how many BezTriples are selected */
-	for (ale= act_data.first; ale; ale= ale->next)
-		count += count_ipo_keys(ale->key_data, side, cfra);
+	for (ale= act_data.first; ale; ale= ale->next) {
+		if (ale->type == ACTTYPE_GPLAYER)
+			count += count_gplayer_frames(ale->data, side, cfra);
+		else
+			count += count_ipo_keys(ale->key_data, side, cfra);
+	}
 	
 	/* stop if trying to build list if nothing selected */
 	if (count == 0) {
@@ -2812,16 +2990,38 @@ static void createTransActionData(TransInfo *t)
 	
 	/* allocate memory for data */
 	t->total= count;
+	
 	t->data= MEM_callocN(t->total*sizeof(TransData), "TransData(Action Editor)");
-	if (t->mode == TFM_TIME_SLIDE)
+	td= t->data;
+	
+	if (datatype == ACTCONT_GPENCIL) {
+		if (t->mode == TFM_TIME_SLIDE) {
+			t->customData= MEM_callocN((sizeof(float)*2)+(sizeof(tGPFtransdata)*count), "TimeSlide + tGPFtransdata");
+			tfd= (tGPFtransdata *)( (float *)(t->customData) + 2 );
+		}
+		else {
+			t->customData= MEM_callocN(sizeof(tGPFtransdata)*count, "tGPFtransdata");
+			tfd= (tGPFtransdata *)(t->customData);
+		}
+	}
+	else if (t->mode == TFM_TIME_SLIDE)
 		t->customData= MEM_callocN(sizeof(float)*2, "TimeSlide Min/Max");
 	
-	td= t->data;
 	/* loop 2: build transdata array */
 	for (ale= act_data.first; ale; ale= ale->next) {
-		Ipo *ipo= (Ipo *)ale->key_data;
-		
-		td= IpoToTransData(td, ipo, ob, side, cfra);
+		if (ale->type == ACTTYPE_GPLAYER) {
+			bGPDlayer *gpl= (bGPDlayer *)ale->data;
+			int i;
+			
+			i = GPLayerToTransData(td, tfd, gpl, side, cfra);
+			td += i;
+			tfd += i;
+		}
+		else {
+			Ipo *ipo= (Ipo *)ale->key_data;
+			
+			td= IpoToTransData(td, ipo, ob, side, cfra);
+		}
 	}
 	
 	/* check if we're supposed to be setting minx/maxx for TimeSlide */
@@ -3623,7 +3823,7 @@ void special_aftertrans_update(TransInfo *t)
 			}
 		}
 	}
-	else if (t->spacetype == SPACE_ACTION) {
+	if (t->spacetype == SPACE_ACTION) {
 		void *data;
 		short datatype;
 		
@@ -3673,6 +3873,13 @@ void special_aftertrans_update(TransInfo *t)
 			
 			DAG_object_flush_update(G.scene, OBACT, OB_RECALC_DATA);
 		}
+		else if (datatype == ACTCONT_GPENCIL) {
+			/* remove duplicate frames and also make sure points are in order! */
+			if ((cancelled == 0) || (duplicate))
+			{
+				posttrans_gpd_clean(data);
+			}
+		}
 		
 		G.saction->flag &= ~SACTION_MOVING;
 	}
diff --git a/source/blender/src/transform_generics.c b/source/blender/src/transform_generics.c
index 6cb7a34d1bc..c332fd723eb 100644
--- a/source/blender/src/transform_generics.c
+++ b/source/blender/src/transform_generics.c
@@ -278,6 +278,11 @@ void recalcData(TransInfo *t)
 		data = get_action_context(&context);
 		if (data == NULL) return;
 		
+		/* always flush data if gpencil context */
+		if (context == ACTCONT_GPENCIL) {
+			flushTransGPactionData(t);
+		}
+		
 		if (G.saction->lock) {
 			if (context == ACTCONT_ACTION) {
 				if(ob) {
@@ -753,6 +758,10 @@ void postTrans (TransInfo *t)
 		if (G.sima->flag & SI_LIVE_UNWRAP)
 			unwrap_lscm_live_end(t->state == TRANS_CANCEL);
 	}
+	else if(t->spacetype==SPACE_ACTION) {
+		if (t->customData)
+			MEM_freeN(t->customData);
+	}
 }
 
 void applyTransObjects(TransInfo *t)
diff --git a/source/blender/src/usiblender.c b/source/blender/src/usiblender.c
index 4aea0df74b9..92e49ab29fa 100644
--- a/source/blender/src/usiblender.c
+++ b/source/blender/src/usiblender.c
@@ -883,7 +883,7 @@ void BIF_write_file(char *target)
 	if (G.f & G_DOSCRIPTLINKS) BPY_do_pyscript(&G.scene->id, SCRIPT_ONSAVE);
 
 	for (li= G.main->library.first; li; li= li->id.next) {
-		if (BLI_streq(li->name, target)) {
+		if (li->parent==NULL && BLI_streq(li->name, target)) {
 			error("Cannot overwrite used library");
 			return;
 		}
diff --git a/source/blender/yafray/SConscript b/source/blender/yafray/SConscript
index dd744f92d39..f5bc03df3b7 100644
--- a/source/blender/yafray/SConscript
+++ b/source/blender/yafray/SConscript
@@ -6,4 +6,4 @@ sources = env.Glob('intern/*.cpp')
 incs = '#/intern/guardedalloc ../blenlib ../makesdna ../blenkernel'
 incs += ' ../imbuf ../include ../render/extern/include ../render/intern/include'
 
-env.BlenderLib ( 'bf_yafray', sources, Split(incs), [], libtype=['blender','player'], priority=[5, 190] )
+env.BlenderLib ( 'bf_yafray', sources, Split(incs), [], libtype=['blender','player'], priority=[5, 190] )
\ No newline at end of file
diff --git a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
index 4af5ac4d5d2..b3a3a47152a 100644
--- a/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
+++ b/source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
@@ -332,6 +332,7 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
 			ketsjiengine->SetPythonDictionary(dictionaryobject);
 			initRasterizer(rasterizer, canvas);
 			PyObject *gameLogic = initGameLogic(startscene);
+			PyDict_SetItemString(dictionaryobject, "GameLogic", gameLogic); // Same as importing the module.
 			initGameKeys();
 			initPythonConstraintBinding();
 
@@ -399,7 +400,14 @@ extern "C" void StartKetsjiShell(struct ScrArea *area,
 				exitstring = ketsjiengine->GetExitString();
 				
 				// when exiting the mainloop
-				dictionaryClearByHand(gameLogic);
+				
+				// Clears the dictionary by hand:
+				// This prevents, extra references to global variables
+				// inside the GameLogic dictionary when the python interpreter is finalized.
+				// which allows the scene to safely delete them :)
+				// see: (space.c)->start_game
+				PyDict_Clear(PyModule_GetDict(gameLogic));
+				
 				ketsjiengine->StopEngine();
 				exitGamePythonScripting();
 				networkdevice->Disconnect();
@@ -591,6 +599,7 @@ extern "C" void StartKetsjiShellSimulation(struct ScrArea *area,
 			ketsjiengine->SetPythonDictionary(dictionaryobject);
 			initRasterizer(rasterizer, canvas);
 			PyObject *gameLogic = initGameLogic(startscene);
+			PyDict_SetItemString(dictionaryobject, "GameLogic", gameLogic); // Same as importing the module
 			initGameKeys();
 			initPythonConstraintBinding();
 
diff --git a/source/gameengine/BlenderRoutines/KX_BlenderCanvas.cpp b/source/gameengine/BlenderRoutines/KX_BlenderCanvas.cpp
index 5f37de24ed6..1604dfe5cce 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderCanvas.cpp
+++ b/source/gameengine/BlenderRoutines/KX_BlenderCanvas.cpp
@@ -101,6 +101,13 @@ int KX_BlenderCanvas::GetHeight(
 	return scrarea_get_win_height(m_area);
 }
 
+RAS_Rect &
+KX_BlenderCanvas::
+GetWindowArea(
+){
+	return m_area_rect;
+}	
+
 	void
 KX_BlenderCanvas::
 SetViewPort(
@@ -112,6 +119,11 @@ SetViewPort(
 	int minx = scrarea_get_win_x(m_area);
 	int miny = scrarea_get_win_y(m_area);
 
+	m_area_rect.SetLeft(minx + x1);
+	m_area_rect.SetBottom(miny + y1);
+	m_area_rect.SetRight(minx + x2);
+	m_area_rect.SetTop(miny + y2);
+
 	glViewport(minx + x1, miny + y1, vp_width, vp_height);
 	glScissor(minx + x1, miny + y1, vp_width, vp_height);
 }
diff --git a/source/gameengine/BlenderRoutines/KX_BlenderCanvas.h b/source/gameengine/BlenderRoutines/KX_BlenderCanvas.h
index b155d39e149..bc202a8558c 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderCanvas.h
+++ b/source/gameengine/BlenderRoutines/KX_BlenderCanvas.h
@@ -117,6 +117,10 @@ public:
 		return m_displayarea;
 	};
 
+		RAS_Rect &
+	GetWindowArea(
+	);
+
 		void
 	SetViewPort(
 		int x1, int y1,
@@ -159,6 +163,7 @@ public:
 private:
 	/** Blender area the game engine is running within */
 	struct ScrArea* m_area;
+	RAS_Rect 	m_area_rect;
 };
 
 #endif // __KX_BLENDERCANVAS
diff --git a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
index 73d2870720a..220d174d464 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
+++ b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.cpp
@@ -483,9 +483,9 @@ void KX_BlenderRenderTools::MotionBlur(RAS_IRasterizer* rasterizer)
 	}
 }
 
-void KX_BlenderRenderTools::Update2DFilter(RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text, short texture_flag)
+void KX_BlenderRenderTools::Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text)
 {
-	m_filtermanager.EnableFilter(filtermode, pass, text, texture_flag);
+	m_filtermanager.EnableFilter(propNames, gameObj, filtermode, pass, text);
 }
 
 void KX_BlenderRenderTools::Render2DFilters(RAS_ICanvas* canvas)
diff --git a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.h b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.h
index 7748e31156d..8abce1b8c3e 100644
--- a/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.h
+++ b/source/gameengine/BlenderRoutines/KX_BlenderRenderTools.h
@@ -101,7 +101,7 @@ public:
 
 	virtual void MotionBlur(RAS_IRasterizer* rasterizer);
 
-	virtual void Update2DFilter(RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text, short texture_flag);
+	virtual void Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text);
 
 	virtual	void Render2DFilters(RAS_ICanvas* canvas);
 
diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index f3e22cd297a..1f1ac6da119 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -1847,7 +1847,10 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 	int aspect_width;
 	int aspect_height;
 	vector<MT_Vector3> inivel,iniang;
-	
+	set<Group*> grouplist;	// list of groups to be converted
+	set<Object*> allblobj;	// all objects converted
+	set<Object*> groupobj;	// objects from groups (never in active layer)
+
 	if (alwaysUseExpandFraming) {
 		frame_type = RAS_FrameSettings::e_frame_extend;
 		aspect_width = canvas->GetWidth();
@@ -1919,6 +1922,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 	for (SETLOOPER(blenderscene, base))
 	{
 		Object* blenderobject = base->object;
+		allblobj.insert(blenderobject);
+
 		KX_GameObject* gameobj = gameobject_from_blenderobject(
 										base->object, 
 										kxscene, 
@@ -2046,7 +2051,9 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 				
 				gameobj->NodeUpdateGS(0,true);
 				gameobj->Bucketize();
-				
+		
+				if (gameobj->IsDupliGroup())
+					grouplist.insert(blenderobject->dup_group);
 			}
 			else
 			{
@@ -2073,6 +2080,188 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 
 	}
 
+	if (!grouplist.empty())
+	{
+		// now convert the group referenced by dupli group object
+		// keep track of all groups already converted
+		set<Group*> allgrouplist = grouplist;
+		set<Group*> tempglist;
+		// recurse
+		while (!grouplist.empty())
+		{
+			set<Group*>::iterator git;
+			tempglist.clear();
+			tempglist.swap(grouplist);
+			for (git=tempglist.begin(); git!=tempglist.end(); git++)
+			{
+				Group* group = *git;
+				GroupObject* go;
+				for(go=(GroupObject*)group->gobject.first; go; go=(GroupObject*)go->next) 
+				{
+					Object* blenderobject = go->ob;
+					if (converter->FindGameObject(blenderobject) == NULL)
+					{
+						allblobj.insert(blenderobject);
+						groupobj.insert(blenderobject);
+						KX_GameObject* gameobj = gameobject_from_blenderobject(
+														blenderobject, 
+														kxscene, 
+														rendertools, 
+														converter,
+														blenderscene);
+										
+						// this code is copied from above except that
+						// object from groups are never is active layer
+						bool isInActiveLayer = false;
+						bool addobj=true;
+						
+						if (converter->addInitFromFrame)
+							if (!isInActiveLayer)
+								addobj=false;
+														
+						if (gameobj&&addobj)
+						{
+							MT_Point3 posPrev;			
+							MT_Matrix3x3 angor;			
+							if (converter->addInitFromFrame) 
+								blenderscene->r.cfra=blenderscene->r.sfra;
+							
+							MT_Point3 pos = MT_Point3(
+								blenderobject->loc[0]+blenderobject->dloc[0],
+								blenderobject->loc[1]+blenderobject->dloc[1],
+								blenderobject->loc[2]+blenderobject->dloc[2]
+							);
+							MT_Vector3 eulxyz = MT_Vector3(
+								blenderobject->rot[0],
+								blenderobject->rot[1],
+								blenderobject->rot[2]
+							);
+							MT_Vector3 scale = MT_Vector3(
+								blenderobject->size[0],
+								blenderobject->size[1],
+								blenderobject->size[2]
+							);
+							if (converter->addInitFromFrame){//rcruiz
+								float eulxyzPrev[3];
+								blenderscene->r.cfra=blenderscene->r.sfra-1;
+								update_for_newframe();
+								MT_Vector3 tmp=pos-MT_Point3(blenderobject->loc[0]+blenderobject->dloc[0],
+															blenderobject->loc[1]+blenderobject->dloc[1],
+															blenderobject->loc[2]+blenderobject->dloc[2]
+													);
+								eulxyzPrev[0]=blenderobject->rot[0];
+								eulxyzPrev[1]=blenderobject->rot[1];
+								eulxyzPrev[2]=blenderobject->rot[2];
+
+								double fps = (double) blenderscene->r.frs_sec/
+									(double) blenderscene->r.frs_sec_base;
+
+								tmp.scale(fps, fps, fps);
+								inivel.push_back(tmp);
+								tmp=eulxyz-eulxyzPrev;
+								tmp.scale(fps, fps, fps);
+								iniang.push_back(tmp);
+								blenderscene->r.cfra=blenderscene->r.sfra;
+								update_for_newframe();
+							}		
+										
+							gameobj->NodeSetLocalPosition(pos);
+							gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
+							gameobj->NodeSetLocalScale(scale);
+							gameobj->NodeUpdateGS(0,true);
+							
+							BL_ConvertIpos(blenderobject,gameobj,converter);
+							// TODO: expand to multiple ipos per mesh
+							Material *mat = give_current_material(blenderobject, 1);
+							if(mat) BL_ConvertMaterialIpos(mat, gameobj, converter);	
+					
+							sumolist->Add(gameobj->AddRef());
+							
+							BL_ConvertProperties(blenderobject,gameobj,timemgr,kxscene,isInActiveLayer);
+							
+					
+							gameobj->SetName(blenderobject->id.name);
+					
+							// templist to find Root Parents (object with no parents)
+							templist->Add(gameobj->AddRef());
+							
+							// update children/parent hierarchy
+							if ((blenderobject->parent != 0)&&(!converter->addInitFromFrame))
+							{
+								// blender has an additional 'parentinverse' offset in each object
+								SG_Node* parentinversenode = new SG_Node(NULL,NULL,SG_Callbacks());
+							
+								// define a normal parent relationship for this node.
+								KX_NormalParentRelation * parent_relation = KX_NormalParentRelation::New();
+								parentinversenode->SetParentRelation(parent_relation);
+					
+								parentChildLink pclink;
+								pclink.m_blenderchild = blenderobject;
+								pclink.m_gamechildnode = parentinversenode;
+								vec_parent_child.push_back(pclink);
+
+								float* fl = (float*) blenderobject->parentinv;
+								MT_Transform parinvtrans(fl);
+								parentinversenode->SetLocalPosition(parinvtrans.getOrigin());
+								parentinversenode->SetLocalOrientation(parinvtrans.getBasis());
+								
+								parentinversenode->AddChild(gameobj->GetSGNode());
+							}
+							
+							// needed for python scripting
+							logicmgr->RegisterGameObjectName(gameobj->GetName(),gameobj);
+
+							// needed for dynamic object morphing
+							logicmgr->RegisterGameObj(gameobj, blenderobject);
+							for (int i = 0; i < gameobj->GetMeshCount(); i++)
+								logicmgr->RegisterGameMeshName(gameobj->GetMesh(i)->GetName(), blenderobject);
+					
+							converter->RegisterGameObject(gameobj, blenderobject);	
+							// this was put in rapidly, needs to be looked at more closely
+							// only draw/use objects in active 'blender' layers
+					
+							logicbrick_conversionlist->Add(gameobj->AddRef());
+							
+							if (converter->addInitFromFrame){
+								posPrev=gameobj->NodeGetWorldPosition();
+								angor=gameobj->NodeGetWorldOrientation();
+							}
+							if (isInActiveLayer)
+							{
+								objectlist->Add(gameobj->AddRef());
+								//tf.Add(gameobj->GetSGNode());
+								
+								gameobj->NodeUpdateGS(0,true);
+								gameobj->Bucketize();
+						
+							}
+							else
+							{
+								//we must store this object otherwise it will be deleted 
+								//at the end of this function if it is not a root object
+								inactivelist->Add(gameobj->AddRef());
+
+							}
+							if (gameobj->IsDupliGroup())
+							{
+								// check that the group is not already converted
+								if (allgrouplist.insert(blenderobject->dup_group).second)
+									grouplist.insert(blenderobject->dup_group);
+							}
+							if (converter->addInitFromFrame){
+								gameobj->NodeSetLocalPosition(posPrev);
+								gameobj->NodeSetLocalOrientation(angor);
+							}
+										
+						}
+						if (gameobj)
+							gameobj->Release();
+					}
+				}
+			}
+		}
+	}
+
 	if (blenderscene->camera) {
 		KX_Camera *gamecamera= (KX_Camera*) converter->FindGameObject(blenderscene->camera);
 		
@@ -2081,15 +2270,18 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 	}
 
 	//	Set up armatures
-	for(SETLOOPER(blenderscene, base)){
-		if (base->object->type==OB_MESH){
-			Mesh *me = (Mesh*)base->object->data;
+	set<Object*>::iterator oit;
+	for(oit=allblobj.begin(); oit!=allblobj.end(); oit++)
+	{
+		Object* blenderobj = *oit;
+		if (blenderobj->type==OB_MESH){
+			Mesh *me = (Mesh*)blenderobj->data;
 	
 			if (me->dvert){
-				KX_GameObject *obj = converter->FindGameObject(base->object);
+				KX_GameObject *obj = converter->FindGameObject(blenderobj);
 	
-				if (base->object->parent && base->object->parent->type==OB_ARMATURE && base->object->partype==PARSKEL){
-					KX_GameObject *par = converter->FindGameObject(base->object->parent);
+				if (obj && blenderobj->parent && blenderobj->parent->type==OB_ARMATURE && blenderobj->partype==PARSKEL){
+					KX_GameObject *par = converter->FindGameObject(blenderobj->parent);
 					if (par)
 						((BL_SkinDeformer*)(((BL_DeformableGameObject*)obj)->m_pDeformer))->SetArmature((BL_ArmatureObject*) par);
 				}
@@ -2174,7 +2366,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 		{
 			meshobj = gameobj->GetMesh(0);
 		}
-		BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,activeLayerBitInfo,physics_engine,converter,processCompoundChildren);
+		int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0;
+		BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,physics_engine,converter,processCompoundChildren);
 	}
 
 	processCompoundChildren = true;
@@ -2189,7 +2382,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 		{
 			meshobj = gameobj->GetMesh(0);
 		}
-		BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,activeLayerBitInfo,physics_engine,converter,processCompoundChildren);
+		int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0;
+		BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,physics_engine,converter,processCompoundChildren);
 	}
 	
 	
@@ -2311,22 +2505,25 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 	{
 		KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
 		struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-		bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-		BL_ConvertActuators(maggie->name, blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,executePriority, activeLayerBitInfo,isInActiveLayer,rendertools,converter);
+		int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+		bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+		BL_ConvertActuators(maggie->name, blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,executePriority, layerMask,isInActiveLayer,rendertools,converter);
 	}
 	for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
 	{
 		KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
 		struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-		bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-		BL_ConvertControllers(blenderobj,gameobj,logicmgr,pythondictionary,executePriority,activeLayerBitInfo,isInActiveLayer,converter);
+		int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+		bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+		BL_ConvertControllers(blenderobj,gameobj,logicmgr,pythondictionary,executePriority,layerMask,isInActiveLayer,converter);
 	}
 	for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
 	{
 		KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
 		struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-		bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-		BL_ConvertSensors(blenderobj,gameobj,logicmgr,kxscene,keydev,executePriority,activeLayerBitInfo,isInActiveLayer,canvas,converter);
+		int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+		bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+		BL_ConvertSensors(blenderobj,gameobj,logicmgr,kxscene,keydev,executePriority,layerMask,isInActiveLayer,canvas,converter);
 	}
 	// apply the initial state to controllers
 	for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
@@ -2344,5 +2541,19 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 	// Calculate the scene btree -
 	// too slow - commented out.
 	//kxscene->SetNodeTree(tf.MakeTree());
+
+	// instantiate dupli group, we will loop trough the object
+	// that are in active layers. Note that duplicating group
+	// has the effect of adding objects at the end of objectlist.
+	// Only loop through the first part of the list.
+	int objcount = objectlist->GetCount();
+	for (i=0;i<objcount;i++)
+	{
+		KX_GameObject* gameobj = (KX_GameObject*) objectlist->GetValue(i);
+		if (gameobj->IsDupliGroup())
+		{
+			kxscene->DupliGroupRecurse(gameobj, 0);
+		}
+	}
 }
 
diff --git a/source/gameengine/Converter/BL_DeformableGameObject.h b/source/gameengine/Converter/BL_DeformableGameObject.h
index 57a404ad72b..315ad18c42c 100644
--- a/source/gameengine/Converter/BL_DeformableGameObject.h
+++ b/source/gameengine/Converter/BL_DeformableGameObject.h
@@ -60,6 +60,7 @@ public:
 	{
 		if (m_pDeformer)
 			m_pDeformer->Relink (map);
+		KX_GameObject::Relink(map);
 	};
 	void ProcessReplica(KX_GameObject* replica);
 
diff --git a/source/gameengine/Converter/BL_ShapeDeformer.cpp b/source/gameengine/Converter/BL_ShapeDeformer.cpp
index eb5c1467ea5..b2e54539b19 100644
--- a/source/gameengine/Converter/BL_ShapeDeformer.cpp
+++ b/source/gameengine/Converter/BL_ShapeDeformer.cpp
@@ -109,6 +109,13 @@ bool BL_ShapeDeformer::ExecuteShapeDrivers(void)
 		vector<IpoCurve*>::iterator it;
 		void *poin;
 		int type;
+		// the shape drivers use the bone matrix as input. Must 
+		// update the matrix now
+		Object* par_arma = m_armobj->GetArmatureObject();
+		m_armobj->ApplyPose();
+		where_is_pose( par_arma ); 
+		PoseApplied(true);
+
 		for (it=m_shapeDrivers.begin(); it!=m_shapeDrivers.end(); it++) {
 			// no need to set a specific time: this curve has a driver
 			IpoCurve *icu = *it;
diff --git a/source/gameengine/Converter/BL_SkinDeformer.cpp b/source/gameengine/Converter/BL_SkinDeformer.cpp
index d3442fe5298..f96c40c098f 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.cpp
+++ b/source/gameengine/Converter/BL_SkinDeformer.cpp
@@ -66,7 +66,8 @@ BL_SkinDeformer::BL_SkinDeformer(BL_DeformableGameObject *gameobj,
 							m_armobj(arma),
 							m_lastArmaUpdate(-1),
 							m_defbase(&bmeshobj->defbase),
-							m_releaseobject(false)
+							m_releaseobject(false),
+							m_poseApplied(false)
 {
 	Mat4CpyMat4(m_obmat, bmeshobj->obmat);
 };
@@ -98,32 +99,28 @@ BL_SkinDeformer::~BL_SkinDeformer()
 		m_armobj->Release();
 }
 
-bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *)
+bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
 {
 	size_t i, j;
 
-	if (!Update())
-		// no need to update the cache
-		return false;
+	// update the vertex in m_transverts
+	Update();
 
-	// Update all materials at once, so we can do the above update test
-	// without ending up with some materials not updated
-	for(RAS_MaterialBucket::Set::iterator mit = m_pMeshObject->GetFirstMaterial();
-		mit != m_pMeshObject->GetLastMaterial(); ++ mit) {
-		RAS_IPolyMaterial *mat = (*mit)->GetPolyMaterial();
+	// The vertex cache can only be updated for this deformer:
+	// Duplicated objects with more than one ploymaterial (=multiple mesh slot per object)
+	// share the same mesh (=the same cache). As the rendering is done per polymaterial
+	// cycling through the objects, the entire mesh cache cannot be updated in one shot.
+	vecVertexArray& vertexarrays = m_pMeshObject->GetVertexCache(mat);
 
-		vecVertexArray& vertexarrays = m_pMeshObject->GetVertexCache(mat);
+	// For each array
+	for (i=0; i<vertexarrays.size(); i++) {
+		KX_VertexArray& vertexarray = (*vertexarrays[i]);
 
-		// For each array
-		for (i=0; i<vertexarrays.size(); i++) {
-			KX_VertexArray& vertexarray = (*vertexarrays[i]);
-
-			// For each vertex
-			// copy the untransformed data from the original mvert
-			for (j=0; j<vertexarray.size(); j++) {
-				RAS_TexVert& v = vertexarray[j];
-				v.SetXYZ(m_transverts[v.getOrigIndex()]);
-			}
+		// For each vertex
+		// copy the untransformed data from the original mvert
+		for (j=0; j<vertexarray.size(); j++) {
+			RAS_TexVert& v = vertexarray[j];
+			v.SetXYZ(m_transverts[v.getOrigIndex()]);
 		}
 	}
 
@@ -153,9 +150,11 @@ bool BL_SkinDeformer::Update(void)
 		
 		/* XXX note: where_is_pose() (from BKE_armature.h) calculates all matrices needed to start deforming */
 		/* but it requires the blender object pointer... */
-
 		Object* par_arma = m_armobj->GetArmatureObject();
-		where_is_pose( par_arma ); 
+		if (!PoseApplied()){
+			m_armobj->ApplyPose();
+			where_is_pose( par_arma ); 
+		}
 
 		/* store verts locally */
 		VerifyStorage();
@@ -180,7 +179,8 @@ bool BL_SkinDeformer::Update(void)
 
 		/* Update the current frame */
 		m_lastArmaUpdate=m_armobj->GetLastFrame();
-		
+		/* reset for next frame */
+		PoseApplied(false);
 		/* indicate that the m_transverts and normals are up to date */
 		return true;
 	}
diff --git a/source/gameengine/Converter/BL_SkinDeformer.h b/source/gameengine/Converter/BL_SkinDeformer.h
index f35db8273c4..d3fc5ae2a81 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.h
+++ b/source/gameengine/Converter/BL_SkinDeformer.h
@@ -81,10 +81,13 @@ public:
 	virtual ~BL_SkinDeformer();
 	bool Update (void);
 	bool Apply (class RAS_IPolyMaterial *polymat);
+	bool PoseApplied()
+		{ return m_poseApplied; }
+	void PoseApplied(bool applied)
+		{ m_poseApplied = applied; }
 	bool PoseUpdated(void)
 		{ 
 			if (m_armobj && m_lastArmaUpdate!=m_armobj->GetLastFrame()) {
-				m_armobj->ApplyPose();
 				return true;
 			}
 			return false;
@@ -102,6 +105,7 @@ protected:
 	ListBase*				m_defbase;
 	float					m_obmat[4][4];	// the reference matrix for skeleton deform
 	bool					m_releaseobject;
+	bool					m_poseApplied;
 
 };
 
diff --git a/source/gameengine/Converter/KX_ConvertActuators.cpp b/source/gameengine/Converter/KX_ConvertActuators.cpp
index 1f87e9d9ac7..f2ec01db839 100644
--- a/source/gameengine/Converter/KX_ConvertActuators.cpp
+++ b/source/gameengine/Converter/KX_ConvertActuators.cpp
@@ -503,7 +503,7 @@ void BL_ConvertActuators(char* maggiename,
 		case ACT_PROPERTY:
 			{
 				bPropertyActuator* propact = (bPropertyActuator*) bact->data;
-				CValue* destinationObj = NULL;
+				SCA_IObject* destinationObj = NULL;
 				
 				/*
 				here the destinationobject is searched. problem with multiple scenes: other scenes
@@ -539,7 +539,7 @@ void BL_ConvertActuators(char* maggiename,
 						
 						// does the 'original' for replication exists, and 
 						// is it in a non-active layer ?
-						CValue* originalval = NULL;
+						SCA_IObject* originalval = NULL;
 						if (editobact->ob && !(editobact->ob->lay & activeLayerBitInfo))
 							originalval = converter->FindGameObject(editobact->ob);
 						
@@ -628,6 +628,8 @@ void BL_ConvertActuators(char* maggiename,
 				/* convert settings... degrees in the ui become radians  */ 
 				/* internally                                            */ 
 				if (conact->type == ACT_CONST_TYPE_ORI) {
+					min = (MT_2_PI * conact->minloc[0])/360.0;
+					max = (MT_2_PI * conact->maxloc[0])/360.0;
 					switch (conact->mode) {
 					case ACT_CONST_DIRPX:
 						locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIX;
@@ -1000,7 +1002,7 @@ void BL_ConvertActuators(char* maggiename,
 			}
             
 			tmp = new SCA_2DFilterActuator(gameobj, filtermode, _2dfilter->flag,
-				_2dfilter->float_arg,_2dfilter->int_arg,_2dfilter->texture_flag,ketsjiEngine->GetRasterizer(),rendertools);
+				_2dfilter->float_arg,_2dfilter->int_arg,ketsjiEngine->GetRasterizer(),rendertools);
 
 			if (_2dfilter->text)
 			{
diff --git a/source/gameengine/Expressions/Value.cpp b/source/gameengine/Expressions/Value.cpp
index f0195d5df82..48136eb9dc3 100644
--- a/source/gameengine/Expressions/Value.cpp
+++ b/source/gameengine/Expressions/Value.cpp
@@ -405,7 +405,20 @@ bool CValue::RemoveProperty(const STR_String & inName)
 	return false;
 }
 
-
+//
+// Get Property Names
+//
+vector<STR_String> CValue::GetPropertyNames()
+{
+	vector<STR_String> result;
+	if(!m_pNamedPropertyArray) return result;
+	for ( std::map<STR_String,CValue*>::iterator it = m_pNamedPropertyArray->begin();
+	!(it == m_pNamedPropertyArray->end());it++)
+	{
+		result.push_back((*it).first);
+	}
+	return result;
+}
 
 //
 // Clear all properties
diff --git a/source/gameengine/Expressions/Value.h b/source/gameengine/Expressions/Value.h
index 561e5521d60..bcf231cf4f0 100644
--- a/source/gameengine/Expressions/Value.h
+++ b/source/gameengine/Expressions/Value.h
@@ -286,6 +286,7 @@ public:
 	STR_String			GetPropertyText(const STR_String & inName,const STR_String& deftext="");						// Get text description of property with name <inName>, returns an empty string if there is no property named <inName>
 	float				GetPropertyNumber(const STR_String& inName,float defnumber);
 	virtual bool		RemoveProperty(const STR_String & inName);						// Remove the property named <inName>, returns true if the property was succesfully removed, false if property was not found or could not be removed
+	virtual vector<STR_String>	GetPropertyNames();
 	virtual void		ClearProperties();										// Clear all properties
 
 	virtual void		SetPropertiesModified(bool inModified);					// Set all properties' modified flag to <inModified>
diff --git a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
index 56249bb52ec..96a770a553f 100644
--- a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
@@ -7,7 +7,6 @@
 #endif
 #include <iostream>
 
-
 SCA_2DFilterActuator::~SCA_2DFilterActuator()
 {
 }
@@ -18,7 +17,6 @@ SCA_2DFilterActuator::SCA_2DFilterActuator(
 		short flag,
 		float float_arg,
 		int int_arg,
-		short texture_flag,
 		RAS_IRasterizer* rasterizer,
 		RAS_IRenderTools* rendertools,
         PyTypeObject* T)
@@ -26,11 +24,15 @@ SCA_2DFilterActuator::SCA_2DFilterActuator(
      m_type(type),
 	 m_flag(flag),
 	 m_int_arg(int_arg),
-	 m_texture_flag(texture_flag),
 	 m_float_arg(float_arg),
 	 m_rasterizer(rasterizer),
 	 m_rendertools(rendertools)
 {
+	m_gameObj = NULL;
+	if(gameobj){
+		m_propNames = gameobj->GetPropertyNames();
+		m_gameObj = gameobj;
+	}
 }
 
 void SCA_2DFilterActuator::SetShaderText(STR_String text)
@@ -52,8 +54,6 @@ CValue* SCA_2DFilterActuator::GetReplica()
 
 bool SCA_2DFilterActuator::Update()
 {
-	bool result = false;
-
 	bool bNegativeEvent = IsNegativeEvent();
 	RemoveAllEvents();
 
@@ -74,7 +74,7 @@ bool SCA_2DFilterActuator::Update()
 	}
 	else if(m_type < RAS_2DFilterManager::RAS_2DFILTER_NUMBER_OF_FILTERS)
 	{
-		m_rendertools->Update2DFilter(m_type, m_int_arg, m_shaderText, m_texture_flag);
+		m_rendertools->Update2DFilter(m_propNames, m_gameObj, m_type, m_int_arg, m_shaderText);
 	}
     return true;
 }
diff --git a/source/gameengine/GameLogic/SCA_2DFilterActuator.h b/source/gameengine/GameLogic/SCA_2DFilterActuator.h
index 451a7b9491a..7ec07cf5b19 100644
--- a/source/gameengine/GameLogic/SCA_2DFilterActuator.h
+++ b/source/gameengine/GameLogic/SCA_2DFilterActuator.h
@@ -5,18 +5,17 @@
 #include "RAS_IRenderTools.h"
 #include "SCA_IActuator.h"
 
-
 class SCA_2DFilterActuator : public SCA_IActuator
 {
     Py_Header;
 
 private:
-	
+	vector<STR_String> m_propNames;
+	void * m_gameObj;
 	RAS_2DFilterManager::RAS_2DFILTER_MODE m_type;
 	short m_flag;
 	float m_float_arg;
 	int   m_int_arg;
-	short m_texture_flag;
 	STR_String	m_shaderText;
 	RAS_IRasterizer* m_rasterizer;
 	RAS_IRenderTools* m_rendertools;
@@ -29,7 +28,6 @@ public:
 		short flag,
 		float float_arg,
 		int int_arg,
-		short texture_flag,
 		RAS_IRasterizer* rasterizer,
 		RAS_IRenderTools* rendertools,
         PyTypeObject* T=&Type
diff --git a/source/gameengine/GameLogic/SCA_ILogicBrick.cpp b/source/gameengine/GameLogic/SCA_ILogicBrick.cpp
index f6efd485adb..e73358bc1e8 100644
--- a/source/gameengine/GameLogic/SCA_ILogicBrick.cpp
+++ b/source/gameengine/GameLogic/SCA_ILogicBrick.cpp
@@ -82,7 +82,10 @@ void SCA_ILogicBrick::ReParent(SCA_IObject* parent)
 	m_gameobj = parent;
 }
 
-
+void SCA_ILogicBrick::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	// nothing to do
+}
 
 CValue* SCA_ILogicBrick::Calc(VALUE_OPERATOR op, CValue *val)
 {
diff --git a/source/gameengine/GameLogic/SCA_ILogicBrick.h b/source/gameengine/GameLogic/SCA_ILogicBrick.h
index 80bc6ae3b86..c28711ac0f6 100644
--- a/source/gameengine/GameLogic/SCA_ILogicBrick.h
+++ b/source/gameengine/GameLogic/SCA_ILogicBrick.h
@@ -32,6 +32,8 @@
 #include "Value.h"
 #include "SCA_IObject.h"
 #include "BoolValue.h"
+#include "GEN_Map.h"
+#include "GEN_HashedPtr.h"
 
 class SCA_ILogicBrick : public CValue
 {
@@ -59,6 +61,7 @@ public:
 
 	SCA_IObject*	GetParent();
 	virtual void	ReParent(SCA_IObject* parent);
+	virtual void	Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
 
 	// act as a BoolValue (with value IsPositiveTrigger)
 	virtual CValue*	Calc(VALUE_OPERATOR op, CValue *val);
diff --git a/source/gameengine/GameLogic/SCA_IObject.cpp b/source/gameengine/GameLogic/SCA_IObject.cpp
index c5bb4a41552..25b4af696ea 100644
--- a/source/gameengine/GameLogic/SCA_IObject.cpp
+++ b/source/gameengine/GameLogic/SCA_IObject.cpp
@@ -306,7 +306,7 @@ const MT_Point3& SCA_IObject::ConvertPythonPylist(PyObject* pylist)
 }
 #endif
 
-void SCA_IObject::Suspend(void)
+void SCA_IObject::Suspend()
 {
 	if ((!m_ignore_activity_culling) 
 		&& (!m_suspended))  {
diff --git a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
index ebe1cd51863..7062f2cef6a 100644
--- a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
@@ -42,7 +42,7 @@
 /* Native functions                                                          */
 /* ------------------------------------------------------------------------- */
 
-SCA_PropertyActuator::SCA_PropertyActuator(SCA_IObject* gameobj,CValue* sourceObj,const STR_String& propname,const STR_String& expr,int acttype,PyTypeObject* T )
+SCA_PropertyActuator::SCA_PropertyActuator(SCA_IObject* gameobj,SCA_IObject* sourceObj,const STR_String& propname,const STR_String& expr,int acttype,PyTypeObject* T )
    :	SCA_IActuator(gameobj,T),
 	m_type(acttype),
 	m_propname(propname),
@@ -51,14 +51,14 @@ SCA_PropertyActuator::SCA_PropertyActuator(SCA_IObject* gameobj,CValue* sourceOb
 {
 	// protect ourselves against someone else deleting the source object
 	// don't protect against ourselves: it would create a dead lock
-	if (m_sourceObj && m_sourceObj != GetParent())
-		m_sourceObj->AddRef();
+	if (m_sourceObj)
+		m_sourceObj->RegisterActuator(this);
 }
 
 SCA_PropertyActuator::~SCA_PropertyActuator()
 {
-	if (m_sourceObj && m_sourceObj != GetParent())
-		m_sourceObj->Release();
+	if (m_sourceObj)
+		m_sourceObj->UnregisterActuator(this);
 }
 
 bool SCA_PropertyActuator::Update()
@@ -185,10 +185,31 @@ void SCA_PropertyActuator::ProcessReplica()
 	// no need to check for self reference like in the constructor:
 	// the replica will always have a different parent
 	if (m_sourceObj)
-		m_sourceObj->AddRef();
+		m_sourceObj->RegisterActuator(this);
 	SCA_IActuator::ProcessReplica();
 }
 
+bool SCA_PropertyActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	if (clientobj == m_sourceObj)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_sourceObj = NULL;
+		return true;
+	}
+	return false;
+}
+
+void SCA_PropertyActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_sourceObj];
+	if (h_obj) {
+		if (m_sourceObj)
+			m_sourceObj->UnregisterActuator(this);
+		m_sourceObj = (SCA_IObject*)(*h_obj);
+		m_sourceObj->RegisterActuator(this);
+	}
+}
 
 
 /* ------------------------------------------------------------------------- */
diff --git a/source/gameengine/GameLogic/SCA_PropertyActuator.h b/source/gameengine/GameLogic/SCA_PropertyActuator.h
index f8305901c51..1e435684572 100644
--- a/source/gameengine/GameLogic/SCA_PropertyActuator.h
+++ b/source/gameengine/GameLogic/SCA_PropertyActuator.h
@@ -52,7 +52,7 @@ class SCA_PropertyActuator : public SCA_IActuator
 	int			m_type;
 	STR_String	m_propname;
 	STR_String	m_exprtxt;
-	CValue*		m_sourceObj; // for copy property actuator
+	SCA_IObject* m_sourceObj; // for copy property actuator
 
 public:
 
@@ -60,7 +60,7 @@ public:
 
 	SCA_PropertyActuator(
 		SCA_IObject* gameobj,
-		CValue* sourceObj,
+		SCA_IObject* sourceObj,
 		const STR_String& propname,
 		const STR_String& expr,
 		int acttype,
@@ -74,7 +74,9 @@ public:
 	GetReplica(
 	);
 
-	void ProcessReplica();
+	virtual void ProcessReplica();
+	virtual bool UnlinkObject(SCA_IObject* clientobj);
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
 
 	virtual bool 
 	Update();
diff --git a/source/gameengine/GameLogic/SCA_PythonController.cpp b/source/gameengine/GameLogic/SCA_PythonController.cpp
index 76386079bdf..01ae4072335 100644
--- a/source/gameengine/GameLogic/SCA_PythonController.cpp
+++ b/source/gameengine/GameLogic/SCA_PythonController.cpp
@@ -116,7 +116,7 @@ CValue* SCA_PythonController::GetReplica()
 
 void SCA_PythonController::SetScriptText(const STR_String& text)
 { 
-	m_scriptText = "import GameLogic\n" + text;
+	m_scriptText = text;
 	m_bModified = true;
 }
 
@@ -354,8 +354,10 @@ SCA_PythonController::PyGetSensor(PyObject* self, PyObject* value)
 			return sensor->AddRef();
 		}
 	}
-		
-	PyErr_SetString(PyExc_AttributeError, "Unable to find requested sensor");
+	
+	char emsg[96];
+	PyOS_snprintf( emsg, sizeof( emsg ), "Unable to find requested sensor \"%s\"", scriptArg );
+	PyErr_SetString(PyExc_AttributeError, emsg);
 	return NULL;
 }
 
@@ -382,8 +384,10 @@ SCA_PythonController::PyGetActuator(PyObject* self, PyObject* value)
 			return actua->AddRef();
 		}
 	}
-		
-	PyErr_SetString(PyExc_AttributeError, "Unable to find requested actuator");
+	
+	char emsg[96];
+	PyOS_snprintf( emsg, sizeof( emsg ), "Unable to find requested actuator \"%s\"", scriptArg );
+	PyErr_SetString(PyExc_AttributeError, emsg);
 	return NULL;
 }
 
diff --git a/source/gameengine/GamePlayer/common/GPC_Canvas.h b/source/gameengine/GamePlayer/common/GPC_Canvas.h
index f82166dfa88..87719041f65 100644
--- a/source/gameengine/GamePlayer/common/GPC_Canvas.h
+++ b/source/gameengine/GamePlayer/common/GPC_Canvas.h
@@ -130,6 +130,12 @@ public:
 	) {
 		return m_displayarea;
 	};
+	
+		RAS_Rect &
+	GetWindowArea(
+	) {
+		return m_displayarea;
+	}
 
 		void 
 	BeginFrame(
diff --git a/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp b/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp
index a5017574873..8b828393c67 100644
--- a/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp
+++ b/source/gameengine/GamePlayer/common/GPC_RenderTools.cpp
@@ -602,9 +602,9 @@ void GPC_RenderTools::MotionBlur(RAS_IRasterizer* rasterizer)
 	}
 }
 
-void GPC_RenderTools::Update2DFilter(RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text, short texture_flag)
+void GPC_RenderTools::Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text)
 {
-	m_filtermanager.EnableFilter(filtermode, pass, text, texture_flag);
+	m_filtermanager.EnableFilter(propNames, gameObj, filtermode, pass, text);
 }
 
 void GPC_RenderTools::Render2DFilters(RAS_ICanvas* canvas)
diff --git a/source/gameengine/GamePlayer/common/GPC_RenderTools.h b/source/gameengine/GamePlayer/common/GPC_RenderTools.h
index cb7193f3513..8fae3d2b305 100644
--- a/source/gameengine/GamePlayer/common/GPC_RenderTools.h
+++ b/source/gameengine/GamePlayer/common/GPC_RenderTools.h
@@ -142,7 +142,7 @@ public:
 
 	virtual void MotionBlur(RAS_IRasterizer* rasterizer);
 
-	virtual void Update2DFilter(RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text, short texture_flag);
+	virtual void Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text);
 
 	virtual	void Render2DFilters(RAS_ICanvas* canvas);
 
diff --git a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
index d6908b53d40..b5ebffb9378 100644
--- a/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
+++ b/source/gameengine/GamePlayer/ghost/GPG_Application.cpp
@@ -644,7 +644,7 @@ bool GPG_Application::startEngine(void)
 		PyObject* dictionaryobject = initGamePlayerPythonScripting("Ketsji", psl_Lowest);
 		m_ketsjiengine->SetPythonDictionary(dictionaryobject);
 		initRasterizer(m_rasterizer, m_canvas);
-		PyObject *gameLogic = initGameLogic(startscene);
+		PyDict_SetItemString(dictionaryobject, "GameLogic", initGameLogic(startscene)); // Same as importing the module
 		initGameKeys();
 		initPythonConstraintBinding();
 
diff --git a/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp b/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
index 70443ced7a9..539eaec4a7b 100644
--- a/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
+++ b/source/gameengine/Ketsji/KX_BulletPhysicsController.cpp
@@ -13,11 +13,13 @@
 #include "KX_ClientObjectInfo.h"
 
 #include "PHY_IPhysicsEnvironment.h"
+#include "CcdPhysicsEnvironment.h"
 
 
 KX_BulletPhysicsController::KX_BulletPhysicsController (const CcdConstructionInfo& ci, bool dyna)
 : KX_IPhysicsController(dyna,(PHY_IPhysicsController*)this),
-CcdPhysicsController(ci)
+CcdPhysicsController(ci),
+m_savedCollisionFlags(0)
 {
 
 }
@@ -131,9 +133,10 @@ void	KX_BulletPhysicsController::getOrientation(MT_Quaternion& orn)
 	CcdPhysicsController::getOrientation(myorn[0],myorn[1],myorn[2],myorn[3]);
 	orn = MT_Quaternion(myorn[0],myorn[1],myorn[2],myorn[3]);
 }
-void KX_BulletPhysicsController::setOrientation(const MT_Quaternion& orn)
+void KX_BulletPhysicsController::setOrientation(const MT_Matrix3x3& orn)
 {
-	CcdPhysicsController::setOrientation(orn.x(),orn.y(),orn.z(),orn.w());
+	btMatrix3x3 btmat(orn[0][0], orn[0][1], orn[0][2], orn[1][0], orn[1][1], orn[1][2], orn[2][0], orn[2][1], orn[2][2]);
+	CcdPhysicsController::setWorldOrientation(btmat);
 }
 void KX_BulletPhysicsController::setPosition(const MT_Point3& pos)
 {
@@ -161,14 +164,37 @@ void	KX_BulletPhysicsController::setRigidBody(bool rigid)
 {
 }
 
-void	KX_BulletPhysicsController::SuspendDynamics()
+void	KX_BulletPhysicsController::SuspendDynamics(bool ghost)
 {
-	GetRigidBody()->setActivationState(DISABLE_SIMULATION);
-
+	btRigidBody *body = GetRigidBody();
+	if (body->getActivationState() != DISABLE_SIMULATION)
+	{
+		btBroadphaseProxy* handle = body->getBroadphaseHandle();
+		m_savedCollisionFlags = body->getCollisionFlags();
+		m_savedMass = GetMass();
+		m_savedCollisionFilterGroup = handle->m_collisionFilterGroup;
+		m_savedCollisionFilterMask = handle->m_collisionFilterMask;
+		body->setActivationState(DISABLE_SIMULATION);
+		GetPhysicsEnvironment()->updateCcdPhysicsController(this, 
+			0.0,
+			btCollisionObject::CF_STATIC_OBJECT|((ghost)?btCollisionObject::CF_NO_CONTACT_RESPONSE:(m_savedCollisionFlags&btCollisionObject::CF_NO_CONTACT_RESPONSE)),
+			btBroadphaseProxy::StaticFilter, 
+			btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
+	}
 }
+
 void	KX_BulletPhysicsController::RestoreDynamics()
 {
-	GetRigidBody()->forceActivationState(ACTIVE_TAG);
+	btRigidBody *body = GetRigidBody();
+	if (body->getActivationState() == DISABLE_SIMULATION)
+	{
+		GetPhysicsEnvironment()->updateCcdPhysicsController(this, 
+			m_savedMass,
+			m_savedCollisionFlags,
+			m_savedCollisionFilterGroup,
+			m_savedCollisionFilterMask);
+		GetRigidBody()->forceActivationState(ACTIVE_TAG);
+	}
 }
 
 SG_Controller*	KX_BulletPhysicsController::GetReplica(class SG_Node* destnode)
diff --git a/source/gameengine/Ketsji/KX_BulletPhysicsController.h b/source/gameengine/Ketsji/KX_BulletPhysicsController.h
index 0853755dffa..2efe0474b30 100644
--- a/source/gameengine/Ketsji/KX_BulletPhysicsController.h
+++ b/source/gameengine/Ketsji/KX_BulletPhysicsController.h
@@ -7,6 +7,11 @@
 
 class KX_BulletPhysicsController : public KX_IPhysicsController ,public CcdPhysicsController
 {
+private:
+	int m_savedCollisionFlags;
+	short int m_savedCollisionFilterGroup;
+	short int m_savedCollisionFilterMask;
+	MT_Scalar m_savedMass;
 
 public:
 
@@ -30,7 +35,7 @@ public:
 	virtual void	SetAngularVelocity(const MT_Vector3& ang_vel,bool local);
 	virtual void	SetLinearVelocity(const MT_Vector3& lin_vel,bool local);
 	virtual	void	getOrientation(MT_Quaternion& orn);
-	virtual	void setOrientation(const MT_Quaternion& orn);
+	virtual	void setOrientation(const MT_Matrix3x3& orn);
 	virtual	void setPosition(const MT_Point3& pos);
 	virtual	void setScaling(const MT_Vector3& scaling);
 	virtual	MT_Scalar	GetMass();
@@ -39,7 +44,7 @@ public:
 
 	virtual void	resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
 
-	virtual void	SuspendDynamics();
+	virtual void	SuspendDynamics(bool ghost);
 	virtual void	RestoreDynamics();
 
 	virtual	SG_Controller*	GetReplica(class SG_Node* destnode);
diff --git a/source/gameengine/Ketsji/KX_CameraActuator.cpp b/source/gameengine/Ketsji/KX_CameraActuator.cpp
index 27f4870de10..0a97b6f0a2f 100644
--- a/source/gameengine/Ketsji/KX_CameraActuator.cpp
+++ b/source/gameengine/Ketsji/KX_CameraActuator.cpp
@@ -49,7 +49,7 @@ STR_String KX_CameraActuator::Y_AXIS_STRING = "y";
 
 KX_CameraActuator::KX_CameraActuator(
 	SCA_IObject* gameobj, 
-	CValue *obj,
+	SCA_IObject *obj,
 	MT_Scalar hght,
 	MT_Scalar minhght,
 	MT_Scalar maxhght,
@@ -63,11 +63,14 @@ KX_CameraActuator::KX_CameraActuator(
 	m_maxHeight (maxhght),
 	m_x (xytog)
 {
+	if (m_ob)
+		m_ob->RegisterActuator(this);
 }
 
 KX_CameraActuator::~KX_CameraActuator()
 {
-	//nothing to do
+	if (m_ob)
+		m_ob->UnregisterActuator(this);
 }
 
 	CValue* 
@@ -81,9 +84,36 @@ GetReplica(
 	return replica;
 };
 
+void KX_CameraActuator::ProcessReplica()
+{
+	if (m_ob)
+		m_ob->RegisterActuator(this);
+	SCA_IActuator::ProcessReplica();
+}
 
+bool KX_CameraActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	if (clientobj == m_ob)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_ob = NULL;
+		return true;
+	}
+	return false;
+}
 
 
+void KX_CameraActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_ob];
+	if (h_obj) {
+		if (m_ob)
+			m_ob->UnregisterActuator(this);
+		m_ob = (SCA_IObject*)(*h_obj);
+		m_ob->RegisterActuator(this);
+	}
+}
+
 /* three functions copied from blender arith... don't know if there's an equivalent */
 
 static float Kx_Normalize(float *n)
@@ -181,8 +211,14 @@ static void Kx_VecUpMat3(float *vec, float mat[][3], short axis)
 
 bool KX_CameraActuator::Update(double curtime, bool frame)
 {
-	bool result = true;
+	/* wondering... is it really neccesary/desirable to suppress negative    */
+	/* events here?                                                          */
+	bool bNegativeEvent = IsNegativeEvent();
+	RemoveAllEvents();
 
+	if (bNegativeEvent || !m_ob) 
+		return false;
+	
 	KX_GameObject *obj = (KX_GameObject*) GetParent();
 	MT_Point3 from = obj->NodeGetWorldPosition();
 	MT_Matrix3x3 frommat = obj->NodeGetWorldOrientation();
@@ -195,13 +231,6 @@ bool KX_CameraActuator::Update(double curtime, bool frame)
 	float mindistsq, maxdistsq, distsq;
 	float mat[3][3];
 	
-	/* wondering... is it really neccesary/desirable to suppress negative    */
-	/* events here?                                                          */
-	bool bNegativeEvent = IsNegativeEvent();
-	RemoveAllEvents();
-
-	if (bNegativeEvent) return false;
-	
 	/* The rules:                                                            */
 	/* CONSTRAINT 1: not implemented */
 	/* CONSTRAINT 2: can camera see actor?              */
@@ -315,7 +344,7 @@ bool KX_CameraActuator::Update(double curtime, bool frame)
 	actormat[2][0]= mat[0][2]; actormat[2][1]= mat[1][2]; actormat[2][2]= mat[2][2];
 	obj->NodeSetLocalOrientation(actormat);
 
-	return result;
+	return true;
 }
 
 CValue *KX_CameraActuator::findObject(char *obName) 
@@ -404,7 +433,11 @@ PyObject* KX_CameraActuator::PySetObject(PyObject* self,
 	PyObject* gameobj;
 	if (PyArg_ParseTuple(args, "O!", &KX_GameObject::Type, &gameobj))
 	{
-		m_ob = (CValue*)gameobj;
+		if (m_ob)
+			m_ob->UnregisterActuator(this);
+		m_ob = (SCA_IObject*)gameobj;
+		if (m_ob)
+			m_ob->RegisterActuator(this);
 		Py_Return;
 	}
 	PyErr_Clear();
@@ -412,10 +445,13 @@ PyObject* KX_CameraActuator::PySetObject(PyObject* self,
 	char* objectname;
 	if (PyArg_ParseTuple(args, "s", &objectname))
 	{
-		CValue *object = (CValue*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));
+		SCA_IObject *object = (SCA_IObject*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));
 		if(object)
 		{
+			if (m_ob != NULL)
+				m_ob->UnregisterActuator(this);
 			m_ob = object;
+			m_ob->RegisterActuator(this);
 			Py_Return;
 		}
 	}
diff --git a/source/gameengine/Ketsji/KX_CameraActuator.h b/source/gameengine/Ketsji/KX_CameraActuator.h
index eb007e403ec..488b36922b0 100644
--- a/source/gameengine/Ketsji/KX_CameraActuator.h
+++ b/source/gameengine/Ketsji/KX_CameraActuator.h
@@ -49,7 +49,7 @@ class KX_CameraActuator : public SCA_IActuator
 	Py_Header;
 private :
 	/** Object that will be tracked. */
-	CValue *m_ob;
+	SCA_IObject *m_ob;
 
 	/** height (float), */
 	//const MT_Scalar m_height;
@@ -87,7 +87,7 @@ private :
 
 		SCA_IObject *gameobj,
 		//const CValue *ob,
-		CValue *ob,
+		SCA_IObject *ob,
 		MT_Scalar hght,
 		MT_Scalar minhght,
 		MT_Scalar maxhght,
@@ -103,6 +103,7 @@ private :
 
 	/** Methods Inherited from  CValue */
 	CValue* GetReplica();
+	virtual void ProcessReplica();
 	
 
 	/** Methods inherited from SCA_IActuator */
@@ -110,7 +111,10 @@ private :
 		double curtime,
 		bool frame
 	);
+	virtual bool	UnlinkObject(SCA_IObject* clientobj);
 
+	/** Methods inherited from SCA_ILogicBrick */
+	virtual void	Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
 
 	/* --------------------------------------------------------------------- */
 	/* Python interface ---------------------------------------------------- */
diff --git a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
index 80288a72485..800416b5f0a 100644
--- a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
@@ -88,11 +88,17 @@ KX_ConstraintActuator::KX_ConstraintActuator(SCA_IObject *gameobj,
 			} else {
 				m_refDirection /= len;
 			}
+			m_minimumBound = cos(minBound);
+			m_maximumBound = cos(maxBound);
+			m_minimumSine = sin(minBound);
+			m_maximumSine = sin(maxBound);
 		}
 		break;
 	default:
 		m_minimumBound = minBound;
 		m_maximumBound = maxBound;
+		m_minimumSine = 0.f;
+		m_maximumSine = 0.f;
 		break;
 	}
 
@@ -153,9 +159,9 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
 		KX_GameObject  *obj = (KX_GameObject*) GetParent();
 		MT_Point3    position = obj->NodeGetWorldPosition();
 		MT_Point3    newposition;
-		MT_Vector3   direction;
+		MT_Vector3   direction, refDirection;
 		MT_Matrix3x3 rotation = obj->NodeGetWorldOrientation();
-		MT_Scalar    filter, newdistance;
+		MT_Scalar    filter, newdistance, cosangle;
 		int axis, sign;
 
 		if (m_posDampTime) {
@@ -178,16 +184,52 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
 				direction[2] = rotation[2][1];
 				axis = 1;
 				break;
-			case KX_ACT_CONSTRAINT_ORIZ:
+			default:
 				direction[0] = rotation[0][2];
 				direction[1] = rotation[1][2];
 				direction[2] = rotation[2][2];
 				axis = 2;
 				break;
 			}
-			// apply damping on the direction
+			if ((m_maximumBound < (1.0f-FLT_EPSILON)) || (m_minimumBound < (1.0f-FLT_EPSILON))) {
+				// reference direction needs to be evaluated
+				// 1. get the cosine between current direction and target
+				cosangle = direction.dot(m_refDirection);
+				if (cosangle >= (m_maximumBound-FLT_EPSILON) && cosangle <= (m_minimumBound+FLT_EPSILON)) {
+					// no change to do
+					result = true;
+					goto CHECK_TIME;
+				}
+				// 2. define a new reference direction
+				//    compute local axis with reference direction as X and
+				//    Y in direction X refDirection plane
+				MT_Vector3 zaxis = m_refDirection.cross(direction);
+				if (MT_fuzzyZero2(zaxis.length2())) {
+					// direction and refDirection are identical,
+					// choose any other direction to define plane
+					if (direction[0] < 0.9999)
+						zaxis = m_refDirection.cross(MT_Vector3(1.0,0.0,0.0));
+					else
+						zaxis = m_refDirection.cross(MT_Vector3(0.0,1.0,0.0));
+				}
+				MT_Vector3 yaxis = zaxis.cross(m_refDirection);
+				yaxis.normalize();
+				if (cosangle > m_minimumBound) {
+					// angle is too close to reference direction,
+					// choose a new reference that is exactly at minimum angle
+					refDirection = m_minimumBound * m_refDirection + m_minimumSine * yaxis;
+				} else {
+					// angle is too large, choose new reference direction at maximum angle
+					refDirection = m_maximumBound * m_refDirection + m_maximumSine * yaxis;
+				}
+			} else {
+				refDirection = m_refDirection;
+			}
 			if (m_posDampTime) {
-				direction = filter*direction + (1.0-filter)*m_refDirection;
+				// apply damping on the direction
+				direction = filter*direction + (1.0-filter)*refDirection;
+			} else {
+				direction = refDirection;
 			}
 			obj->AlignAxisToVect(direction, axis);
 			result = true;
diff --git a/source/gameengine/Ketsji/KX_ConstraintActuator.h b/source/gameengine/Ketsji/KX_ConstraintActuator.h
index 5a1d4d23217..3ef51595098 100644
--- a/source/gameengine/Ketsji/KX_ConstraintActuator.h
+++ b/source/gameengine/Ketsji/KX_ConstraintActuator.h
@@ -48,6 +48,10 @@ protected:
 	float m_minimumBound;
 	// max (float)
 	float m_maximumBound;
+	// sinus of minimum angle
+	float m_minimumSine;
+	// sinus of maximum angle
+	float m_maximumSine;
 	// reference direction
 	MT_Vector3 m_refDirection;
 	// locrotxyz choice (pick one): only one choice allowed at a time!
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index 2ac4f909077..185f456c83a 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -61,6 +61,8 @@ typedef unsigned long uint_ptr;
 #include "KX_RayCast.h"
 #include "KX_PythonInit.h"
 #include "KX_PyMath.h"
+#include "SCA_IActuator.h"
+#include "SCA_ISensor.h"
 
 // This file defines relationships between parents and children
 // in the game engine.
@@ -222,6 +224,10 @@ void KX_GameObject::SetParent(KX_Scene *scene, KX_GameObject* obj)
 		RemoveParent(scene);
 		obj->GetSGNode()->AddChild(GetSGNode());
 
+		if (m_pPhysicsController1) 
+		{
+			m_pPhysicsController1->SuspendDynamics(true);
+		}
 		// Set us to our new scale, position, and orientation
 		scale1[0] = scale1[0]/scale2[0];
 		scale1[1] = scale1[1]/scale2[1];
@@ -258,6 +264,10 @@ void KX_GameObject::RemoveParent(KX_Scene *scene)
 		if (!rootlist->SearchValue(this))
 			// object was not in root list, add it now and increment ref count
 			rootlist->Add(AddRef());
+		if (m_pPhysicsController1) 
+		{
+			m_pPhysicsController1->RestoreDynamics();
+		}
 	}
 }
 
@@ -714,8 +724,12 @@ MT_Vector3 KX_GameObject::GetAngularVelocity(bool local)
 
 void KX_GameObject::NodeSetLocalPosition(const MT_Point3& trans)
 {
-	if (m_pPhysicsController1)
+	if (m_pPhysicsController1 && (!GetSGNode() || !GetSGNode()->GetSGParent()))
 	{
+		// don't update physic controller if the object is a child:
+		// 1) the transformation will not be right
+		// 2) in this case, the physic controller is necessarily a static object
+		//    that is updated from the normal kinematic synchronization
 		m_pPhysicsController1->setPosition(trans);
 	}
 
@@ -727,25 +741,22 @@ void KX_GameObject::NodeSetLocalPosition(const MT_Point3& trans)
 
 void KX_GameObject::NodeSetLocalOrientation(const MT_Matrix3x3& rot)
 {
-	if (m_pPhysicsController1)
+	if (m_pPhysicsController1 && (!GetSGNode() || !GetSGNode()->GetSGParent()))
 	{
-		m_pPhysicsController1->setOrientation(rot.getRotation());
+		// see note above
+		m_pPhysicsController1->setOrientation(rot);
 	}
 	if (GetSGNode())
 		GetSGNode()->SetLocalOrientation(rot);
-	else
-	{
-		int i;
-		i=0;
-	}
 }
 
 
 
 void KX_GameObject::NodeSetLocalScale(const MT_Vector3& scale)
 {
-	if (m_pPhysicsController1)
+	if (m_pPhysicsController1 && (!GetSGNode() || !GetSGNode()->GetSGParent()))
 	{
+		// see note above
 		m_pPhysicsController1->setScaling(scale);
 	}
 	
@@ -832,7 +843,7 @@ void KX_GameObject::Resume(void)
 	}
 }
 
-void KX_GameObject::Suspend(void)
+void KX_GameObject::Suspend()
 {
 	if ((!m_ignore_activity_culling) 
 		&& (!m_suspended))  {
@@ -875,6 +886,8 @@ PyMethodDef KX_GameObject::Methods[] = {
 	{"getParent", (PyCFunction)KX_GameObject::sPyGetParent,METH_NOARGS},
 	{"setParent", (PyCFunction)KX_GameObject::sPySetParent,METH_O},
 	{"removeParent", (PyCFunction)KX_GameObject::sPyRemoveParent,METH_NOARGS},
+	{"getChildren", (PyCFunction)KX_GameObject::sPyGetChildren,METH_NOARGS},
+	{"getChildrenRecursive", (PyCFunction)KX_GameObject::sPyGetChildrenRecursive,METH_NOARGS},
 	{"getMesh", (PyCFunction)KX_GameObject::sPyGetMesh,METH_VARARGS},
 	{"getPhysicsId", (PyCFunction)KX_GameObject::sPyGetPhysicsId,METH_NOARGS},
 	{"getPropertyNames", (PyCFunction)KX_GameObject::sPyGetPropertyNames,METH_NOARGS},
@@ -1292,6 +1305,43 @@ PyObject* KX_GameObject::PyRemoveParent(PyObject* self)
 	Py_RETURN_NONE;
 }
 
+
+static void walk_children(SG_Node* node, CListValue* list, bool recursive)
+{
+	NodeList& children = node->GetSGChildren();
+
+	for (NodeList::iterator childit = children.begin();!(childit==children.end());++childit)
+	{
+		SG_Node* childnode = (*childit);
+		CValue* childobj = (CValue*)childnode->GetSGClientObject();
+		if (childobj != NULL) // This is a GameObject
+		{
+			// add to the list
+			list->Add(childobj->AddRef());
+		}
+		
+		// if the childobj is NULL then this may be an inverse parent link
+		// so a non recursive search should still look down this node.
+		if (recursive || childobj==NULL) {
+			walk_children(childnode, list, recursive);
+		}
+	}
+}
+
+PyObject* KX_GameObject::PyGetChildren(PyObject* self)
+{
+	CListValue* list = new CListValue();
+	walk_children(m_pSGNode, list, 0);
+	return list;
+}
+
+PyObject* KX_GameObject::PyGetChildrenRecursive(PyObject* self)
+{
+	CListValue* list = new CListValue();
+	walk_children(m_pSGNode, list, 1);
+	return list;
+}
+
 PyObject* KX_GameObject::PyGetMesh(PyObject* self, 
 								   PyObject* args, 
 								   PyObject* kwds)
@@ -1660,6 +1710,20 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
  * --------------------------------------------------------------------- */
 void KX_GameObject::Relink(GEN_Map<GEN_HashedPtr, void*> *map_parameter)	
 {
-	/* intentionally empty ? */
+	// we will relink the sensors and actuators that use object references
+	// if the object is part of the replicated hierarchy, use the new
+	// object reference instead
+	SCA_SensorList& sensorlist = GetSensors();
+	SCA_SensorList::iterator sit;
+	for (sit=sensorlist.begin(); sit != sensorlist.end(); sit++)
+	{
+		(*sit)->Relink(map_parameter);
+	}
+	SCA_ActuatorList& actuatorlist = GetActuators();
+	SCA_ActuatorList::iterator ait;
+	for (ait=actuatorlist.begin(); ait != actuatorlist.end(); ait++)
+	{
+		(*ait)->Relink(map_parameter);
+	}
 }
 
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index ddbf863aa1a..6051cf850b5 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -47,6 +47,7 @@
 #include "KX_Scene.h"
 #include "KX_KetsjiEngine.h" /* for m_anim_framerate */
 #include "KX_IPhysicsController.h" /* for suspend/resume */
+#include "DNA_object_types.h"
 #define KX_OB_DYNAMIC 1
 
 
@@ -392,6 +393,13 @@ public:
 		m_pBlenderObject = obj;
 	}
 	
+	bool IsDupliGroup()
+	{ 
+		return (m_pBlenderObject &&
+				(m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
+				m_pBlenderObject->dup_group != NULL) ? true : false;
+	}
+
 	/**
 	 * Set the Scene graph node for this game object.
 	 * warning - it is your responsibility to make sure
@@ -738,6 +746,8 @@ public:
 	KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
 	KX_PYMETHOD_O(KX_GameObject,SetParent);
 	KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetChildren);	
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetChildrenRecursive);
 	KX_PYMETHOD(KX_GameObject,GetMesh);
 	KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
 	KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
diff --git a/source/gameengine/Ketsji/KX_IPhysicsController.h b/source/gameengine/Ketsji/KX_IPhysicsController.h
index 2ec66a883eb..ecfdb8c4275 100644
--- a/source/gameengine/Ketsji/KX_IPhysicsController.h
+++ b/source/gameengine/Ketsji/KX_IPhysicsController.h
@@ -71,14 +71,15 @@ public:
 	virtual void	resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ) = 0;
 
 	virtual	void	getOrientation(MT_Quaternion& orn)=0;
-	virtual	void setOrientation(const MT_Quaternion& orn)=0;
+	virtual	void setOrientation(const MT_Matrix3x3& orn)=0;
+	//virtual	void setOrientation(const MT_Quaternion& orn)=0;
 	virtual	void setPosition(const MT_Point3& pos)=0;
 	virtual	void setScaling(const MT_Vector3& scaling)=0;
 	virtual	MT_Scalar	GetMass()=0;
 	virtual	MT_Vector3	getReactionForce()=0;
 	virtual void	setRigidBody(bool rigid)=0;
 
-	virtual void	SuspendDynamics()=0;
+	virtual void	SuspendDynamics(bool ghost=false)=0;
 	virtual void	RestoreDynamics()=0;
 
 	virtual	SG_Controller*	GetReplica(class SG_Node* destnode)=0;
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
index 20187a193ba..db099d56b55 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
@@ -231,7 +231,10 @@ void KX_KetsjiEngine::SetRasterizer(RAS_IRasterizer* rasterizer)
 }
 
 
-
+/*
+ * At the moment the GameLogic module is imported into 'pythondictionary' after this function is called.
+ * if this function ever changes to assign a copy, make sure the game logic module is imported into this dictionary before hand.
+ */
 void KX_KetsjiEngine::SetPythonDictionary(PyObject* pythondictionary)
 {
 	MT_assert(pythondictionary);
diff --git a/source/gameengine/Ketsji/KX_NearSensor.cpp b/source/gameengine/Ketsji/KX_NearSensor.cpp
index d69871275b9..89699d80031 100644
--- a/source/gameengine/Ketsji/KX_NearSensor.cpp
+++ b/source/gameengine/Ketsji/KX_NearSensor.cpp
@@ -135,9 +135,6 @@ CValue* KX_NearSensor::GetReplica()
 
 void KX_NearSensor::ReParent(SCA_IObject* parent)
 {
-
-	SCA_ISensor::ReParent(parent);
-	
 	m_client_info->m_gameobject = static_cast<KX_GameObject*>(parent); 
 	m_client_info->m_sensors.push_back(this);
 	
@@ -151,6 +148,7 @@ void KX_NearSensor::ReParent(SCA_IObject* parent)
 */
 	((KX_GameObject*)GetParent())->GetSGNode()->ComputeWorldTransforms(NULL);
 	SynchronizeTransform();
+	SCA_ISensor::ReParent(parent);
 }
 
 
diff --git a/source/gameengine/Ketsji/KX_OdePhysicsController.cpp b/source/gameengine/Ketsji/KX_OdePhysicsController.cpp
index 4e45ce484e3..05feb11a2bc 100644
--- a/source/gameengine/Ketsji/KX_OdePhysicsController.cpp
+++ b/source/gameengine/Ketsji/KX_OdePhysicsController.cpp
@@ -133,8 +133,9 @@ void	KX_OdePhysicsController::SetLinearVelocity(const MT_Vector3& lin_vel,bool l
 	ODEPhysicsController::SetLinearVelocity(lin_vel[0],lin_vel[1],lin_vel[2],local);
 }
 
-void KX_OdePhysicsController::setOrientation(const MT_Quaternion& orn)
+void KX_OdePhysicsController::setOrientation(const MT_Matrix3x3& rot)
 {
+	MT_Quaternion orn = rot.getRotation();
 	ODEPhysicsController::setOrientation(orn[0],orn[1],orn[2],orn[3]);
 }
 
@@ -177,7 +178,7 @@ void	KX_OdePhysicsController::setRigidBody(bool rigid)
 
 }
 
-void	KX_OdePhysicsController::SuspendDynamics()
+void	KX_OdePhysicsController::SuspendDynamics(bool)
 {
 	ODEPhysicsController::SuspendDynamics();
 }
diff --git a/source/gameengine/Ketsji/KX_OdePhysicsController.h b/source/gameengine/Ketsji/KX_OdePhysicsController.h
index 07a0bee9775..18f9edc6835 100644
--- a/source/gameengine/Ketsji/KX_OdePhysicsController.h
+++ b/source/gameengine/Ketsji/KX_OdePhysicsController.h
@@ -67,14 +67,14 @@ public:
 	virtual void	SetLinearVelocity(const MT_Vector3& lin_vel,bool local);
 	virtual void		resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
 	virtual	void		getOrientation(MT_Quaternion& orn);
-	virtual	void setOrientation(const MT_Quaternion& orn);
+	virtual	void setOrientation(const MT_Matrix3x3& orn);
 	virtual	void setPosition(const MT_Point3& pos);
 	virtual	void setScaling(const MT_Vector3& scaling);
 	virtual	MT_Scalar	GetMass();
 	virtual	MT_Vector3	getReactionForce();
 	virtual void	setRigidBody(bool rigid);
 
-	virtual void	SuspendDynamics();
+	virtual void	SuspendDynamics(bool);
 	virtual void	RestoreDynamics();
 	
 
diff --git a/source/gameengine/Ketsji/KX_ParentActuator.cpp b/source/gameengine/Ketsji/KX_ParentActuator.cpp
index 8b379bcd44f..fd1b56838e2 100644
--- a/source/gameengine/Ketsji/KX_ParentActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ParentActuator.cpp
@@ -46,19 +46,22 @@
 
 KX_ParentActuator::KX_ParentActuator(SCA_IObject *gameobj, 
 									 int mode,
-									 CValue *ob,
+									 SCA_IObject *ob,
 									 PyTypeObject* T)
 	: SCA_IActuator(gameobj, T),
 	  m_mode(mode),
 	  m_ob(ob)
 {
+	if (m_ob)
+		m_ob->RegisterActuator(this);
 } 
 
 
 
 KX_ParentActuator::~KX_ParentActuator()
 {
-	/* intentionally empty */ 
+	if (m_ob)
+		m_ob->UnregisterActuator(this);
 } 
 
 
@@ -73,6 +76,36 @@ CValue* KX_ParentActuator::GetReplica()
 	return replica;
 }
 
+void KX_ParentActuator::ProcessReplica()
+{
+	if (m_ob)
+		m_ob->RegisterActuator(this);
+	SCA_IActuator::ProcessReplica();
+}
+
+
+bool KX_ParentActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	if (clientobj == m_ob)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_ob = NULL;
+		return true;
+	}
+	return false;
+}
+
+void KX_ParentActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_ob];
+	if (h_obj) {
+		if (m_ob)
+			m_ob->UnregisterActuator(this);
+		m_ob = (SCA_IObject*)(*h_obj);
+		m_ob->RegisterActuator(this);
+	}
+}
+
 
 
 bool KX_ParentActuator::Update()
@@ -87,7 +120,8 @@ bool KX_ParentActuator::Update()
 	KX_Scene *scene = PHY_GetActiveScene();
 	switch (m_mode) {
 		case KX_PARENT_SET:
-			obj->SetParent(scene, (KX_GameObject*)m_ob);
+			if (m_ob)
+				obj->SetParent(scene, (KX_GameObject*)m_ob);
 			break;
 		case KX_PARENT_REMOVE:
 			obj->RemoveParent(scene);
@@ -148,7 +182,11 @@ PyObject* KX_ParentActuator::PySetObject(PyObject* self, PyObject* args, PyObjec
 	PyObject* gameobj;
 	if (PyArg_ParseTuple(args, "O!", &KX_GameObject::Type, &gameobj))
 	{
-		m_ob = (CValue*)gameobj;
+		if (m_ob != NULL)
+			m_ob->UnregisterActuator(this);
+		m_ob = (SCA_IObject*)gameobj;
+		if (m_ob)
+			m_ob->RegisterActuator(this);
 		Py_Return;
 	}
 	PyErr_Clear();
@@ -156,10 +194,13 @@ PyObject* KX_ParentActuator::PySetObject(PyObject* self, PyObject* args, PyObjec
 	char* objectname;
 	if (PyArg_ParseTuple(args, "s", &objectname))
 	{
-		CValue *object = (CValue*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));
+		SCA_IObject *object = (SCA_IObject*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));
 		if(object)
 		{
+			if (m_ob != NULL)
+				m_ob->UnregisterActuator(this);
 			m_ob = object;
+			m_ob->RegisterActuator(this);
 			Py_Return;
 		}
 	}
diff --git a/source/gameengine/Ketsji/KX_ParentActuator.h b/source/gameengine/Ketsji/KX_ParentActuator.h
index 86dcd4e6c12..93b07cd424b 100644
--- a/source/gameengine/Ketsji/KX_ParentActuator.h
+++ b/source/gameengine/Ketsji/KX_ParentActuator.h
@@ -47,7 +47,7 @@ class KX_ParentActuator : public SCA_IActuator
 	int m_mode;
 	
 	/** Object to set as parent */
-	CValue *m_ob;
+	SCA_IObject *m_ob;
 	
 	
 
@@ -62,12 +62,15 @@ class KX_ParentActuator : public SCA_IActuator
  
 	KX_ParentActuator(class SCA_IObject* gameobj,
 						int mode,
-						CValue *ob,
+						SCA_IObject *ob,
 						PyTypeObject* T=&Type);
 	virtual ~KX_ParentActuator();
 	virtual bool Update();
 	
 	virtual CValue* GetReplica();
+	virtual void ProcessReplica();
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
+	virtual bool UnlinkObject(SCA_IObject* clientobj);
 	
 	/* --------------------------------------------------------------------- */
 	/* Python interface ---------------------------------------------------- */
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index 433e0636833..61ed8b6a8e4 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -828,20 +828,9 @@ PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
 		Py_FatalError("can't initialize module GameLogic");
     }
 
-	return d;
+	return m;
 }
 
-void dictionaryClearByHand(PyObject *dict)
-{
-	// Clears the dictionary by hand:
-	// This prevents, extra references to global variables
-	// inside the GameLogic dictionary when the python interpreter is finalized.
-	// which allows the scene to safely delete them :)
-	// see: (space.c)->start_game
-  	if(dict) PyDict_Clear(dict);
-}
-
-
 // Python Sandbox code
 // override builtin functions import() and open()
 
diff --git a/source/gameengine/Ketsji/KX_PythonInit.h b/source/gameengine/Ketsji/KX_PythonInit.h
index c7d8f1b78bc..41cf7fd67b3 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.h
+++ b/source/gameengine/Ketsji/KX_PythonInit.h
@@ -47,7 +47,6 @@ PyObject*	initGamePlayerPythonScripting(const STR_String& progname, TPythonSecur
 void		exitGamePlayerPythonScripting();
 PyObject*	initGamePythonScripting(const STR_String& progname, TPythonSecurityLevel level);
 void		exitGamePythonScripting();
-void		dictionaryClearByHand(PyObject *dict);
 
 void PHY_SetActiveScene(class KX_Scene* scene);
 class KX_Scene* PHY_GetActiveScene();
diff --git a/source/gameengine/Ketsji/KX_RadarSensor.cpp b/source/gameengine/Ketsji/KX_RadarSensor.cpp
index 987e0b946b2..de4979ac4c9 100644
--- a/source/gameengine/Ketsji/KX_RadarSensor.cpp
+++ b/source/gameengine/Ketsji/KX_RadarSensor.cpp
@@ -80,10 +80,7 @@ CValue* KX_RadarSensor::GetReplica()
 {
 	KX_RadarSensor* replica = new KX_RadarSensor(*this);
 	replica->m_colliders = new CListValue();
-	replica->m_bCollision = false;
-	replica->m_bTriggered= false;
-	replica->m_hitObject = NULL;
-	replica->m_bLastTriggered = false;
+	replica->Init();
 	// this will copy properties and so on...
 	CValue::AddDataToReplica(replica);
 	
@@ -92,6 +89,10 @@ CValue* KX_RadarSensor::GetReplica()
 	if (replica->m_physCtrl)
 	{
 		replica->m_physCtrl = replica->m_physCtrl->GetReplica();
+		if (replica->m_physCtrl)
+		{
+			replica->m_physCtrl->setNewClientInfo(replica->m_client_info);
+		}
 	}
 
 	//todo: make sure replication works fine!
@@ -175,8 +176,10 @@ void KX_RadarSensor::SynchronizeTransform()
 
 	if (m_physCtrl)
 	{
-		m_physCtrl->setPosition(trans.getOrigin().x(),trans.getOrigin().y(),trans.getOrigin().z());
-		m_physCtrl->setOrientation(trans.getRotation().x(),trans.getRotation().y(),trans.getRotation().z(),trans.getRotation().w());
+		MT_Quaternion orn = trans.getRotation();
+		MT_Point3 pos = trans.getOrigin();
+		m_physCtrl->setPosition(pos[0],pos[1],pos[2]);
+		m_physCtrl->setOrientation(orn[0],orn[1],orn[2],orn[3]);
 		m_physCtrl->calcXform();
 	}
 
diff --git a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
index 76ce086ab97..e36891b56f4 100644
--- a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
@@ -48,7 +48,7 @@
 /* ------------------------------------------------------------------------- */
 
 KX_SCA_AddObjectActuator::KX_SCA_AddObjectActuator(SCA_IObject *gameobj,
-												   CValue* original,
+												   SCA_IObject *original,
 												   int time,
 												   SCA_IScene* scene,
 												   const MT_Vector3& linvel,
@@ -61,6 +61,9 @@ KX_SCA_AddObjectActuator::KX_SCA_AddObjectActuator(SCA_IObject *gameobj,
 	m_linear_velocity(linvel),
 	m_localFlag(local)
 {
+	if (m_OriginalObject)
+		m_OriginalObject->RegisterActuator(this);
+
 	m_lastCreatedObject = NULL;
 	m_timeProp = time;
 } 
@@ -69,6 +72,8 @@ KX_SCA_AddObjectActuator::KX_SCA_AddObjectActuator(SCA_IObject *gameobj,
 
 KX_SCA_AddObjectActuator::~KX_SCA_AddObjectActuator()
 { 
+	if (m_OriginalObject)
+		m_OriginalObject->UnregisterActuator(this);
 	if (m_lastCreatedObject)
 		m_lastCreatedObject->Release();
 } 
@@ -108,12 +113,40 @@ CValue* KX_SCA_AddObjectActuator::GetReplica()
 
 	// this will copy properties and so on...
 	replica->ProcessReplica();
-	replica->m_lastCreatedObject=NULL;
 	CValue::AddDataToReplica(replica);
 
 	return replica;
 }
 
+void KX_SCA_AddObjectActuator::ProcessReplica()
+{
+	if (m_OriginalObject)
+		m_OriginalObject->RegisterActuator(this);
+	m_lastCreatedObject=NULL;
+	SCA_IActuator::ProcessReplica();
+}
+
+bool KX_SCA_AddObjectActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	if (clientobj == m_OriginalObject)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_OriginalObject = NULL;
+		return true;
+	}
+	return false;
+}
+
+void KX_SCA_AddObjectActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_OriginalObject];
+	if (h_obj) {
+		if (m_OriginalObject)
+			m_OriginalObject->UnregisterActuator(this);
+		m_OriginalObject = (SCA_IObject*)(*h_obj);
+		m_OriginalObject->RegisterActuator(this);
+	}
+}
 
 
 /* ------------------------------------------------------------------------- */
@@ -181,7 +214,11 @@ PyObject* KX_SCA_AddObjectActuator::PySetObject(PyObject* self,
 	PyObject* gameobj;
 	if (PyArg_ParseTuple(args, "O!", &KX_GameObject::Type, &gameobj))
 	{
-		m_OriginalObject = (CValue*)gameobj;
+		if (m_OriginalObject != NULL)
+			m_OriginalObject->UnregisterActuator(this);
+		m_OriginalObject = (SCA_IObject*)gameobj;
+		if (m_OriginalObject)
+			m_OriginalObject->RegisterActuator(this);
 		Py_Return;
 	}
 	PyErr_Clear();
@@ -189,8 +226,11 @@ PyObject* KX_SCA_AddObjectActuator::PySetObject(PyObject* self,
 	char* objectname;
 	if (PyArg_ParseTuple(args, "s", &objectname))
 	{
-		m_OriginalObject= (CValue*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));;
-		
+		if (m_OriginalObject != NULL)
+			m_OriginalObject->UnregisterActuator(this);
+		m_OriginalObject = (SCA_IObject*)SCA_ILogicBrick::m_sCurrentLogicManager->GetGameObjectByName(STR_String(objectname));;
+		if (m_OriginalObject)
+			m_OriginalObject->RegisterActuator(this);
 		Py_Return;
 	}
 	
diff --git a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h
index 2126a646303..1359f39278d 100644
--- a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h
+++ b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h
@@ -53,7 +53,7 @@ class KX_SCA_AddObjectActuator : public SCA_IActuator
 	int	m_timeProp;
 
 	/// Original object reference (object to replicate)  	
-	CValue*	m_OriginalObject;
+	SCA_IObject*	m_OriginalObject;
 
 	/// Object will be added to the following scene
 	SCA_IScene*	m_scene;
@@ -75,7 +75,7 @@ public:
 
 	KX_SCA_AddObjectActuator(
 		SCA_IObject *gameobj,
-		CValue* original,
+		SCA_IObject *original,
 		int time,
 		SCA_IScene* scene,
 		const MT_Vector3& linvel,
@@ -89,6 +89,15 @@ public:
 	GetReplica(
 	) ;
 
+	virtual void 
+	ProcessReplica();
+
+	virtual bool 
+	UnlinkObject(SCA_IObject* clientobj);
+
+	virtual void 
+	Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
+
 	virtual bool 
 	Update();
 
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 065800379d8..c374b9d6fd1 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -66,6 +66,8 @@
 #include "SG_Controller.h"
 #include "SG_IObject.h"
 #include "SG_Tree.h"
+#include "DNA_group_types.h"
+#include "BKE_anim.h"
 
 #include "KX_SG_NodeRelationships.h"
 
@@ -429,6 +431,11 @@ void KX_Scene::RemoveNodeDestructObject(class SG_IObject* node,class CValue* gam
 
 KX_GameObject* KX_Scene::AddNodeReplicaObject(class SG_IObject* node, class CValue* gameobj)
 {
+	// for group duplication, limit the duplication of the hierarchy to the
+	// objects that are part of the group. 
+	if (!IsObjectInGroup(gameobj))
+		return NULL;
+	
 	KX_GameObject* orgobj = (KX_GameObject*)gameobj;
 	KX_GameObject* newobj = (KX_GameObject*)orgobj->GetReplica();
 	m_map_gameobject_to_replica.insert(orgobj, newobj);
@@ -506,6 +513,11 @@ KX_GameObject* KX_Scene::AddNodeReplicaObject(class SG_IObject* node, class CVal
 // hierarchy that's because first ALL bricks must exist in the new
 // replica of the hierarchy in order to make cross-links work properly
 // !
+// It is VERY important that the order of sensors and actuators in
+// the replicated object is preserved: it is is used to reconnect the logic.
+// This method is more robust then using the bricks name in case of complex 
+// group replication. The replication of logic bricks is done in 
+// SCA_IObject::ReParentLogic(), make sure it preserves the order of the bricks.
 void KX_Scene::ReplicateLogic(KX_GameObject* newobj)
 {
 	// also relink the controller to sensors/actuators
@@ -528,37 +540,38 @@ void KX_Scene::ReplicateLogic(KX_GameObject* newobj)
 		for (vector<SCA_ISensor*>::iterator its = linkedsensors.begin();!(its==linkedsensors.end());its++)
 		{
 			SCA_ISensor* oldsensor = (*its);
-			STR_String name = oldsensor->GetName();
-			//find this name in the list
-			SCA_ISensor* newsensor = newobj->FindSensor(name);
+			SCA_IObject* oldsensorobj = oldsensor->GetParent();
+			SCA_IObject* newsensorobj = NULL;
 		
-			if (newsensor)
+			// the original owner of the sensor has been replicated?
+			void **h_obj = m_map_gameobject_to_replica[oldsensorobj];
+			if (h_obj)
+				newsensorobj = (SCA_IObject*)(*h_obj);
+			if (!newsensorobj)
 			{
-				// relink this newsensor to the controller
-				m_logicmgr->RegisterToSensor(cont,newsensor);
+				// no, then the sensor points outside the hierachy, keep it the same
+				if (m_objectlist->SearchValue(oldsensorobj))
+					// only replicate links that points to active objects
+					m_logicmgr->RegisterToSensor(cont,oldsensor);
 			}
 			else
 			{
-				// it can be linked somewhere in the hierarchy or...
-				for (vector<KX_GameObject*>::iterator git = m_logicHierarchicalGameObjects.begin();
-				!(git==m_logicHierarchicalGameObjects.end());++git)
-				{
-					newsensor = (*git)->FindSensor(name);
-					if (newsensor)
-						break;
-				} 
+				// yes, then the new sensor has the same position
+				SCA_SensorList& sensorlist = oldsensorobj->GetSensors();
+				SCA_SensorList::iterator sit;
+				SCA_ISensor* newsensor = NULL;
+				int sensorpos;
 
-				if (newsensor)
-				{
-					// relink this newsensor to the controller somewhere else within this
-					// hierarchy
-					m_logicmgr->RegisterToSensor(cont,newsensor);
-				}
-				else
+				for (sensorpos=0, sit=sensorlist.begin(); sit!=sensorlist.end(); sit++, sensorpos++)
 				{
-					// must be an external sensor, so...
-					m_logicmgr->RegisterToSensor(cont,oldsensor);
+					if ((*sit) == oldsensor) 
+					{
+						newsensor = newsensorobj->GetSensors().at(sensorpos);
+						break;
+					}
 				}
+				assert(newsensor != NULL);
+				m_logicmgr->RegisterToSensor(cont,newsensor);
 			}
 		}
 		
@@ -566,38 +579,40 @@ void KX_Scene::ReplicateLogic(KX_GameObject* newobj)
 		for (vector<SCA_IActuator*>::iterator ita = linkedactuators.begin();!(ita==linkedactuators.end());ita++)
 		{
 			SCA_IActuator* oldactuator = (*ita);
-			STR_String name = oldactuator->GetName();
-			//find this name in the list
-			SCA_IActuator* newactuator = newobj->FindActuator(name);
-			if (newactuator)
+			SCA_IObject* oldactuatorobj = oldactuator->GetParent();
+			SCA_IObject* newactuatorobj = NULL;
+
+			// the original owner of the sensor has been replicated?
+			void **h_obj = m_map_gameobject_to_replica[oldactuatorobj];
+			if (h_obj)
+				newactuatorobj = (SCA_IObject*)(*h_obj);
+
+			if (!newactuatorobj)
 			{
-				// relink this newsensor to the controller
-				m_logicmgr->RegisterToActuator(cont,newactuator);
-				newactuator->SetUeberExecutePriority(m_ueberExecutionPriority);
+				// no, then the sensor points outside the hierachy, keep it the same
+				if (m_objectlist->SearchValue(oldactuatorobj))
+					// only replicate links that points to active objects
+					m_logicmgr->RegisterToActuator(cont,oldactuator);
 			}
 			else
 			{
-				// it can be linked somewhere in the hierarchy or...
-				for (vector<KX_GameObject*>::iterator git = m_logicHierarchicalGameObjects.begin();
-				!(git==m_logicHierarchicalGameObjects.end());++git)
-				{
-					newactuator= (*git)->FindActuator(name);
-					if (newactuator)
-						break;
-				} 
+				// yes, then the new sensor has the same position
+				SCA_ActuatorList& actuatorlist = oldactuatorobj->GetActuators();
+				SCA_ActuatorList::iterator ait;
+				SCA_IActuator* newactuator = NULL;
+				int actuatorpos;
 
-				if (newactuator)
+				for (actuatorpos=0, ait=actuatorlist.begin(); ait!=actuatorlist.end(); ait++, actuatorpos++)
 				{
-					// relink this actuator to the controller somewhere else within this
-					// hierarchy
-					m_logicmgr->RegisterToActuator(cont,newactuator);
-					newactuator->SetUeberExecutePriority(m_ueberExecutionPriority);
-				}
-				else
-				{
-					// must be an external actuator, so...
-					m_logicmgr->RegisterToActuator(cont,oldactuator);
+					if ((*ait) == oldactuator) 
+					{
+						newactuator = newactuatorobj->GetActuators().at(actuatorpos);
+						break;
+					}
 				}
+				assert(newactuator != NULL);
+				m_logicmgr->RegisterToActuator(cont,newactuator);
+				newactuator->SetUeberExecutePriority(m_ueberExecutionPriority);
 			}
 		}
 	}
@@ -605,6 +620,150 @@ void KX_Scene::ReplicateLogic(KX_GameObject* newobj)
 	newobj->ResetState();
 }
 
+void KX_Scene::DupliGroupRecurse(CValue* obj, int level)
+{
+	KX_GameObject* groupobj = (KX_GameObject*) obj;
+	KX_GameObject* replica;
+	KX_GameObject* gameobj;
+	Object* blgroupobj = groupobj->GetBlenderObject();
+	Group* group;
+	GroupObject *go;
+	vector<KX_GameObject*> duplilist;
+
+	if (!groupobj->IsDupliGroup() ||
+		level>MAX_DUPLI_RECUR)
+		return;
+
+	// we will add one group at a time
+	m_logicHierarchicalGameObjects.clear();
+	m_map_gameobject_to_replica.clear();
+	m_ueberExecutionPriority++;
+	// for groups will do something special: 
+	// we will force the creation of objects to those in the group only
+	// Again, this is match what Blender is doing (it doesn't care of parent relationship)
+	m_groupGameObjects.clear();
+
+	group = blgroupobj->dup_group;
+	for(go=(GroupObject*)group->gobject.first; go; go=(GroupObject*)go->next) 
+	{
+		Object* blenderobj = go->ob;
+		if (blgroupobj == blenderobj)
+			// this check is also in group_duplilist()
+			continue;
+		gameobj = m_sceneConverter->FindGameObject(blenderobj);
+		if (gameobj == NULL) 
+		{
+			// this object has not been converted!!!
+			// Should not happen as dupli group are created automatically 
+			continue;
+		}
+		if (blenderobj->lay & group->layer==0)
+		{
+			// object is not visible in the 3D view, will not be instantiated
+			continue;
+		}
+		m_groupGameObjects.insert(gameobj);
+	}
+
+	set<CValue*>::iterator oit;
+	for (oit=m_groupGameObjects.begin(); oit != m_groupGameObjects.end(); oit++)
+	{
+		gameobj = (KX_GameObject*)(*oit);
+		if (gameobj->GetParent() != NULL)
+		{
+			// this object is not a top parent. Either it is the child of another
+			// object in the group and it will be added automatically when the parent
+			// is added. Or it is the child of an object outside the group and the group
+			// is inconsistent, skip it anyway
+			continue;
+		}
+		replica = (KX_GameObject*) AddNodeReplicaObject(NULL,gameobj);
+		// add to 'rootparent' list (this is the list of top hierarchy objects, updated each frame)
+		m_parentlist->Add(replica->AddRef());
+
+		// recurse replication into children nodes
+		NodeList& children = gameobj->GetSGNode()->GetSGChildren();
+
+		replica->GetSGNode()->ClearSGChildren();
+		for (NodeList::iterator childit = children.begin();!(childit==children.end());++childit)
+		{
+			SG_Node* orgnode = (*childit);
+			SG_Node* childreplicanode = orgnode->GetSGReplica();
+			if (childreplicanode)
+				replica->GetSGNode()->AddChild(childreplicanode);
+		}
+		// don't replicate logic now: we assume that the objects in the group can have
+		// logic relationship, even outside parent relationship
+		// In order to match 3D view, the position of groupobj is used as a 
+		// transformation matrix instead of the new position. This means that 
+		// the group reference point is 0,0,0
+
+		// get the rootnode's scale
+		MT_Vector3 newscale = groupobj->NodeGetWorldScaling();
+		// set the replica's relative scale with the rootnode's scale
+		replica->NodeSetRelativeScale(newscale);
+
+		MT_Matrix3x3 newori = groupobj->NodeGetWorldOrientation() * gameobj->NodeGetWorldOrientation();
+		replica->NodeSetLocalOrientation(newori);
+
+		MT_Point3 newpos = groupobj->NodeGetWorldPosition() + 
+			newscale*(groupobj->NodeGetWorldOrientation() * gameobj->NodeGetWorldPosition());
+		replica->NodeSetLocalPosition(newpos);
+
+		if (replica->GetPhysicsController())
+		{
+			// not required, already done in NodeSetLocalOrientation..
+			//replica->GetPhysicsController()->setPosition(newpos);
+			//replica->GetPhysicsController()->setOrientation(newori.getRotation());
+			// Scaling has been set relatively hereabove, this does not 
+			// set the scaling of the controller. I don't know why it's just the
+			// relative scale and not the full scale that has to be put here...
+			replica->GetPhysicsController()->setScaling(newscale);
+		}
+
+		replica->GetSGNode()->UpdateWorldData(0);
+		replica->GetSGNode()->SetBBox(gameobj->GetSGNode()->BBox());
+		replica->GetSGNode()->SetRadius(gameobj->GetSGNode()->Radius());
+		// done with replica
+		replica->Release();
+	}
+
+	// the logic must be replicated first because we need
+	// the new logic bricks before relinking
+	vector<KX_GameObject*>::iterator git;
+	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+	{
+		(*git)->ReParentLogic();
+	}
+	
+	//	relink any pointers as necessary, sort of a temporary solution
+	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+	{
+		// this will also relink the actuator to objects within the hierarchy
+		(*git)->Relink(&m_map_gameobject_to_replica);
+		// add the object in the layer of the parent
+		(*git)->SetLayer(groupobj->GetLayer());
+	}
+
+	// replicate crosslinks etc. between logic bricks
+	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+	{
+		ReplicateLogic((*git));
+	}
+	
+	// now look if object in the hierarchy have dupli group and recurse
+	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+	{
+		if ((*git) != groupobj && (*git)->IsDupliGroup())
+			// can't instantiate group immediately as it destroys m_logicHierarchicalGameObjects
+			duplilist.push_back((*git));
+	}
+
+	for (git = duplilist.begin(); !(git == duplilist.end()); ++git)
+	{
+		DupliGroupRecurse((*git), level+1);
+	}
+}
 
 
 SCA_IObject* KX_Scene::AddReplicaObject(class CValue* originalobject,
@@ -614,6 +773,7 @@ SCA_IObject* KX_Scene::AddReplicaObject(class CValue* originalobject,
 
 	m_logicHierarchicalGameObjects.clear();
 	m_map_gameobject_to_replica.clear();
+	m_groupGameObjects.clear();
 
 	// todo: place a timebomb in the object, for temporarily objects :)
 	// lifespan of zero means 'this object lives forever'
@@ -647,24 +807,26 @@ SCA_IObject* KX_Scene::AddReplicaObject(class CValue* originalobject,
 	{
 		SG_Node* orgnode = (*childit);
 		SG_Node* childreplicanode = orgnode->GetSGReplica();
-		replica->GetSGNode()->AddChild(childreplicanode);
+		if (childreplicanode)
+			replica->GetSGNode()->AddChild(childreplicanode);
 	}
 
-	//	relink any pointers as necessary, sort of a temporary solution
+	// now replicate logic
 	vector<KX_GameObject*>::iterator git;
 	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
 	{
+		(*git)->ReParentLogic();
+	}
+	
+	//	relink any pointers as necessary, sort of a temporary solution
+	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+	{
+		// this will also relink the actuators in the hierarchy
 		(*git)->Relink(&m_map_gameobject_to_replica);
 		// add the object in the layer of the parent
 		(*git)->SetLayer(parentobj->GetLayer());
 	}
 
-	// now replicate logic
-	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
-	{
-		(*git)->ReParentLogic();
-	}
-	
 	// replicate crosslinks etc. between logic bricks
 	for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
 	{
@@ -685,8 +847,9 @@ SCA_IObject* KX_Scene::AddReplicaObject(class CValue* originalobject,
 
 	if (replica->GetPhysicsController())
 	{
-		replica->GetPhysicsController()->setPosition(newpos);
-		replica->GetPhysicsController()->setOrientation(newori.getRotation());
+		// not needed, already done in NodeSetLocalPosition()
+		//replica->GetPhysicsController()->setPosition(newpos);
+		//replica->GetPhysicsController()->setOrientation(newori.getRotation());
 		replica->GetPhysicsController()->setScaling(newscale);
 	}
 
diff --git a/source/gameengine/Ketsji/KX_Scene.h b/source/gameengine/Ketsji/KX_Scene.h
index 28dee1b5893..80a2abe287a 100644
--- a/source/gameengine/Ketsji/KX_Scene.h
+++ b/source/gameengine/Ketsji/KX_Scene.h
@@ -216,6 +216,16 @@ protected:
 	 */
 	std::vector<KX_GameObject*>	m_logicHierarchicalGameObjects;
 	
+	/**
+	 * This temporary variable will contain the list of 
+	 * object that can be added during group instantiation.
+	 * objects outside this list will not be added (can 
+	 * happen with children that are outside the group).
+	 * Used in AddReplicaObject. If the list is empty, it
+	 * means don't care.
+	 */
+	std::set<CValue*>	m_groupGameObjects;
+	
 	/** 
 	 * Pointer to system variable passed in in constructor
 	 * only used in constructor so we do not need to keep it
@@ -291,6 +301,12 @@ public:
 	 * Update all transforms according to the scenegraph.
 	 */
 	void UpdateParents(double curtime);
+	void DupliGroupRecurse(CValue* gameobj, int level);
+	bool IsObjectInGroup(CValue* gameobj)
+	{ 
+		return (m_groupGameObjects.empty() || 
+				m_groupGameObjects.find(gameobj) != m_groupGameObjects.end());
+	}
 	SCA_IObject* AddReplicaObject(CValue* gameobj,
 								  CValue* locationobj,
 								  int lifespan=0);
diff --git a/source/gameengine/Ketsji/KX_SceneActuator.cpp b/source/gameengine/Ketsji/KX_SceneActuator.cpp
index 8f7cffd506f..d6164dc812a 100644
--- a/source/gameengine/Ketsji/KX_SceneActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SceneActuator.cpp
@@ -58,13 +58,16 @@ KX_SceneActuator::KX_SceneActuator(SCA_IObject *gameobj,
 	m_KetsjiEngine=ketsjiEngine;
 	m_camera = camera;
 	m_nextSceneName = nextSceneName;
+	if (m_camera)
+		m_camera->RegisterActuator(this);
 } /* End of constructor */
 
 
 
 KX_SceneActuator::~KX_SceneActuator()
 { 
-	// there's nothing to be done here, really....
+	if (m_camera)
+		m_camera->UnregisterActuator(this);
 } /* end of destructor */
 
 
@@ -79,6 +82,34 @@ CValue* KX_SceneActuator::GetReplica()
 	return replica;
 }
 
+void KX_SceneActuator::ProcessReplica()
+{
+	if (m_camera)
+		m_camera->RegisterActuator(this);
+	SCA_IActuator::ProcessReplica();
+}
+
+bool KX_SceneActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	if (clientobj == (SCA_IObject*)m_camera)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_camera = NULL;
+		return true;
+	}
+	return false;
+}
+
+void KX_SceneActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_camera];
+	if (h_obj) {
+		if (m_camera)
+			m_camera->UnregisterActuator(this);
+		m_camera = (KX_Camera*)(*h_obj);
+		m_camera->RegisterActuator(this);
+	}
+}
 
 
 bool KX_SceneActuator::Update()
@@ -332,7 +363,11 @@ PyObject* KX_SceneActuator::PySetCamera(PyObject* self,
 	PyObject *cam;
 	if (PyArg_ParseTuple(args, "O!", &KX_Camera::Type, &cam))
 	{
+		if (m_camera)
+			m_camera->UnregisterActuator(this);
 		m_camera = (KX_Camera*) cam;
+		if (m_camera)
+			m_camera->RegisterActuator(this);
 		Py_Return;
 	}
 	PyErr_Clear();
@@ -345,7 +380,13 @@ PyObject* KX_SceneActuator::PySetCamera(PyObject* self,
 	}
 
 	KX_Camera *camOb = FindCamera(camName);
-	if (camOb) m_camera = camOb;
+	if (camOb) 
+	{
+		if (m_camera)
+			m_camera->UnregisterActuator(this);
+		m_camera = camOb;
+		m_camera->RegisterActuator(this);
+	}
 
 	Py_Return;
 }
diff --git a/source/gameengine/Ketsji/KX_SceneActuator.h b/source/gameengine/Ketsji/KX_SceneActuator.h
index cfc79b93f8e..55aaf629d7c 100644
--- a/source/gameengine/Ketsji/KX_SceneActuator.h
+++ b/source/gameengine/Ketsji/KX_SceneActuator.h
@@ -82,6 +82,9 @@ class KX_SceneActuator : public SCA_IActuator
 	virtual ~KX_SceneActuator();
 
 	virtual CValue* GetReplica();
+	virtual void ProcessReplica();
+	virtual bool UnlinkObject(SCA_IObject* clientobj);
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
 
 	virtual bool Update();
 	
diff --git a/source/gameengine/Ketsji/KX_SoundActuator.cpp b/source/gameengine/Ketsji/KX_SoundActuator.cpp
index 949156571a7..34a3baec093 100644
--- a/source/gameengine/Ketsji/KX_SoundActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SoundActuator.cpp
@@ -291,7 +291,8 @@ PyObject* KX_SoundActuator::PyGetFilename(PyObject* self, PyObject* args, PyObje
 	char* name = objectname.Ptr();
 	
 	if (!name) {
-		Py_Return;					/* internal error */
+		PyErr_SetString(PyExc_RuntimeError, "Unable to get sound filename");
+		return NULL;
 	} else
 		return PyString_FromString(name);
 }
diff --git a/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp b/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp
index 6ea5461dbaa..4032a795ce3 100644
--- a/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp
+++ b/source/gameengine/Ketsji/KX_SumoPhysicsController.cpp
@@ -101,7 +101,7 @@ void	KX_SumoPhysicsController::SetSumoTransform(bool nondynaonly)
 
 }
 
-void	KX_SumoPhysicsController::SuspendDynamics()
+void	KX_SumoPhysicsController::SuspendDynamics(bool)
 {
 	SumoPhysicsController::SuspendDynamics();
 }
@@ -170,8 +170,9 @@ void	KX_SumoPhysicsController::setMargin(float collisionMargin)
 }
 
 
-void KX_SumoPhysicsController::setOrientation(const MT_Quaternion& orn)
+void KX_SumoPhysicsController::setOrientation(const MT_Matrix3x3& rot)
 {
+	MT_Quaternion orn = rot.getRotation();
 	SumoPhysicsController::setOrientation(
 		orn[0],orn[1],orn[2],orn[3]);
 
diff --git a/source/gameengine/Ketsji/KX_SumoPhysicsController.h b/source/gameengine/Ketsji/KX_SumoPhysicsController.h
index 8c061ae4056..1dd930bf3d9 100644
--- a/source/gameengine/Ketsji/KX_SumoPhysicsController.h
+++ b/source/gameengine/Ketsji/KX_SumoPhysicsController.h
@@ -76,10 +76,10 @@ public:
 	void	resolveCombinedVelocities(float linvelX,float linvelY,float linvelZ,float angVelX,float angVelY,float angVelZ);
 
 
-	void	SuspendDynamics();
+	void	SuspendDynamics(bool);
 	void	RestoreDynamics();
 	virtual	void	getOrientation(MT_Quaternion& orn);
-	virtual	void setOrientation(const MT_Quaternion& orn);
+	virtual	void setOrientation(const MT_Matrix3x3& orn);
 	
 	virtual	void setPosition(const MT_Point3& pos);
 	virtual	void setScaling(const MT_Vector3& scaling);
diff --git a/source/gameengine/Ketsji/KX_TrackToActuator.cpp b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
index 731a610c2eb..c580aa4d4e5 100644
--- a/source/gameengine/Ketsji/KX_TrackToActuator.cpp
+++ b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
@@ -210,6 +210,18 @@ bool KX_TrackToActuator::UnlinkObject(SCA_IObject* clientobj)
 	return false;
 }
 
+void KX_TrackToActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_object];
+	if (h_obj) {
+		if (m_object)
+			m_object->UnregisterActuator(this);
+		m_object = (SCA_IObject*)(*h_obj);
+		m_object->RegisterActuator(this);
+	}
+}
+
+
 bool KX_TrackToActuator::Update(double curtime, bool frame)
 {
 	bool result = false;	
diff --git a/source/gameengine/Ketsji/KX_TrackToActuator.h b/source/gameengine/Ketsji/KX_TrackToActuator.h
index a03aa115baa..1d1cf46d21b 100644
--- a/source/gameengine/Ketsji/KX_TrackToActuator.h
+++ b/source/gameengine/Ketsji/KX_TrackToActuator.h
@@ -68,6 +68,7 @@ class KX_TrackToActuator : public SCA_IActuator
 
 	virtual void ProcessReplica();
 	virtual bool UnlinkObject(SCA_IObject* clientobj);
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
 	virtual bool Update(double curtime, bool frame);
 
 	/* Python part */
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
index e444c4c73be..5c70b071661 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.cpp
@@ -337,12 +337,33 @@ void		CcdPhysicsController::setOrientation(float quatImag0,float quatImag1,float
 		{
 			m_body->setCollisionFlags(m_body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
 		}
-
-		m_MotionState->setWorldOrientation(quatImag0,quatImag1,quatImag2,quatReal);
+		// not required
+		//m_MotionState->setWorldOrientation(quatImag0,quatImag1,quatImag2,quatReal);
 		btTransform xform  = m_body->getCenterOfMassTransform();
 		xform.setRotation(btQuaternion(quatImag0,quatImag1,quatImag2,quatReal));
 		m_body->setCenterOfMassTransform(xform);
-		m_bulletMotionState->setWorldTransform(xform);
+		// not required
+		//m_bulletMotionState->setWorldTransform(xform);
+	}
+
+}
+
+void CcdPhysicsController::setWorldOrientation(const btMatrix3x3& orn)
+{
+	if (m_body)
+	{
+		m_body->activate(true);
+		if (m_body->isStaticObject())
+		{
+			m_body->setCollisionFlags(m_body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
+		}
+		// not required
+		//m_MotionState->setWorldOrientation(quatImag0,quatImag1,quatImag2,quatReal);
+		btTransform xform  = m_body->getCenterOfMassTransform();
+		xform.setBasis(orn);
+		m_body->setCenterOfMassTransform(xform);
+		// not required
+		//m_bulletMotionState->setWorldTransform(xform);
 	}
 
 }
@@ -356,12 +377,13 @@ void		CcdPhysicsController::setPosition(float posX,float posY,float posZ)
 		{
 			m_body->setCollisionFlags(m_body->getCollisionFlags() | btCollisionObject::CF_KINEMATIC_OBJECT);
 		}
-		
-		m_MotionState->setWorldPosition(posX,posY,posZ);
+		// not required, this function is only used to update the physic controller
+		//m_MotionState->setWorldPosition(posX,posY,posZ);
 		btTransform xform  = m_body->getCenterOfMassTransform();
 		xform.setOrigin(btVector3(posX,posY,posZ));
 		m_body->setCenterOfMassTransform(xform);
-		m_bulletMotionState->setWorldTransform(xform);
+		// not required
+		//m_bulletMotionState->setWorldTransform(xform);
 	}
 
 
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsController.h b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
index 37fa465351f..64f1876e199 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsController.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsController.h
@@ -106,6 +106,7 @@ class CcdPhysicsController : public PHY_IPhysicsController
 	btRigidBody* m_body;
 	class PHY_IMotionState*		m_MotionState;
 	btMotionState* 	m_bulletMotionState;
+	friend class CcdPhysicsEnvironment;	// needed when updating the controller
 
 
 	void*		m_newClientInfo;
@@ -115,6 +116,9 @@ class CcdPhysicsController : public PHY_IPhysicsController
 
 	void CreateRigidbody();
 
+	protected:
+		void setWorldOrientation(const btMatrix3x3& mat);
+
 	public:
 	
 		int				m_collisionDelay;
@@ -194,7 +198,6 @@ class CcdPhysicsController : public PHY_IPhysicsController
 			return m_cci.m_collisionFilterMask;
 		}
 
-
 		virtual void	calcXform() {} ;
 		virtual void SetMargin(float margin) {};
 		virtual float GetMargin() const {return 0.f;};
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
index c9d346e316d..b773f40650b 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.cpp
@@ -466,6 +466,38 @@ void	CcdPhysicsEnvironment::removeCcdPhysicsController(CcdPhysicsController* ctr
 
 }
 
+void	CcdPhysicsEnvironment::updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask)
+{
+	// this function is used when the collisionning group of a controller is changed
+	// remove and add the collistioning object
+	btRigidBody* body = ctrl->GetRigidBody();
+	btVector3 inertia;
+
+	m_dynamicsWorld->removeCollisionObject(body);
+	body->setCollisionFlags(newCollisionFlags);
+	body->getCollisionShape()->calculateLocalInertia(newMass, inertia);
+	body->setMassProps(newMass, inertia);
+	m_dynamicsWorld->addCollisionObject(body, newCollisionGroup, newCollisionMask);
+	// to avoid nasty interaction, we must update the property of the controller as well
+	ctrl->m_cci.m_mass = newMass;
+	ctrl->m_cci.m_collisionFilterGroup = newCollisionGroup;
+	ctrl->m_cci.m_collisionFilterMask = newCollisionMask;
+	ctrl->m_cci.m_collisionFlags = newCollisionFlags;
+}
+
+void CcdPhysicsEnvironment::enableCcdPhysicsController(CcdPhysicsController* ctrl)
+{
+	std::vector<CcdPhysicsController*>::iterator i =
+		std::find(m_controllers.begin(), m_controllers.end(), ctrl);
+	if (i == m_controllers.end())
+	{
+		btRigidBody* body = ctrl->GetRigidBody();
+		m_dynamicsWorld->addCollisionObject(body, 
+			ctrl->GetCollisionFilterGroup(), ctrl->GetCollisionFilterMask());
+	}
+}
+
+
 
 void	CcdPhysicsEnvironment::beginFrame()
 {
diff --git a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
index 9f14cf6cbef..453749b27b3 100644
--- a/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
+++ b/source/gameengine/Physics/Bullet/CcdPhysicsEnvironment.h
@@ -183,6 +183,15 @@ protected:
 
 		void	removeCcdPhysicsController(CcdPhysicsController* ctrl);
 
+		void	updateCcdPhysicsController(CcdPhysicsController* ctrl, btScalar newMass, int newCollisionFlags, short int newCollisionGroup, short int newCollisionMask);
+
+		void	disableCcdPhysicsController(CcdPhysicsController* ctrl)
+		{ 
+			removeCcdPhysicsController(ctrl); 
+		}
+
+		void	enableCcdPhysicsController(CcdPhysicsController* ctrl);
+
 		btBroadphaseInterface*	getBroadphase();
 
 		
diff --git a/source/gameengine/PyDoc/KX_GameObject.py b/source/gameengine/PyDoc/KX_GameObject.py
index 37c188b7f22..8f17cf26f15 100644
--- a/source/gameengine/PyDoc/KX_GameObject.py
+++ b/source/gameengine/PyDoc/KX_GameObject.py
@@ -214,6 +214,18 @@ class KX_GameObject:
 		"""
 		Removes this objects parent.
 		"""
+	def getChildren():
+		"""
+		Return a list of immediate children of this object.
+		@rtype: list
+		@return: a list of all this objects children.
+		"""
+	def getChildrenRecursive():
+		"""
+		Return a list of children of this object, including all their childrens children.
+		@rtype: list
+		@return: a list of all this objects children recursivly.
+		"""
 	def getMesh(mesh):
 		"""
 		Gets the mesh object for this object.
diff --git a/source/gameengine/Rasterizer/CMakeLists.txt b/source/gameengine/Rasterizer/CMakeLists.txt
index 18a755afefd..6d53ee53471 100644
--- a/source/gameengine/Rasterizer/CMakeLists.txt
+++ b/source/gameengine/Rasterizer/CMakeLists.txt
@@ -32,6 +32,8 @@ SET(INC
   ../../../intern/string
   ../../../intern/moto/include
   ../../../extern/glew/include
+  ../Expressions
+  ${PYTHON_INC}
 )
 
 BLENDERLIB(bf_rasterizer "${SRC}" "${INC}")
diff --git a/source/gameengine/Rasterizer/Makefile b/source/gameengine/Rasterizer/Makefile
index 1ca3e3b0283..e3b1f274ee5 100644
--- a/source/gameengine/Rasterizer/Makefile
+++ b/source/gameengine/Rasterizer/Makefile
@@ -41,6 +41,9 @@ CPPFLAGS += -I$(NAN_STRING)/include
 CPPFLAGS += -I$(NAN_MOTO)/include
 CPPFLAGS += -I../../kernel/gen_system
 CPPFLAGS += -I../BlenderRoutines
+CPPFLAGS += -I../Expressions
+
+CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION)
 
 ifeq ($(OS),darwin)
 	CPPFLAGS += -fpascal-strings
diff --git a/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp b/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
index 23153fcd86c..ef206332057 100644
--- a/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
+++ b/source/gameengine/Rasterizer/RAS_2DFilterManager.cpp
@@ -43,6 +43,7 @@
 
 #include "STR_String.h"
 #include "RAS_ICanvas.h"
+#include "RAS_Rect.h"
 #include "RAS_2DFilterManager.h"
 #include <iostream>
 
@@ -52,6 +53,7 @@
 #include <config.h>
 #endif
 
+#include "Value.h"
 
 RAS_2DFilterManager::RAS_2DFilterManager():
 texturewidth(-1), textureheight(-1),
@@ -73,12 +75,14 @@ numberoffilters(0)
 		m_filters[passindex] = 0;
 		m_enabled[passindex] = 0;
 		texflag[passindex] = 0;
+		m_gameObjects[passindex] = NULL;
 	}
 	texname[0] = texname[1] = texname[2] = -1;
 }
 
 RAS_2DFilterManager::~RAS_2DFilterManager()
 {
+	FreeTextures();
 }
 
 unsigned int RAS_2DFilterManager::CreateShaderProgram(char* shadersource)
@@ -150,6 +154,28 @@ unsigned int RAS_2DFilterManager::CreateShaderProgram(int filtermode)
 		}
 		return 0;
 }
+void	RAS_2DFilterManager::AnalyseShader(int passindex, vector<STR_String>& propNames)
+{
+	texflag[passindex] = 0;
+	if(glGetUniformLocationARB(m_filters[passindex], "bgl_DepthTexture") != -1)
+	{
+		if(GLEW_ARB_depth_texture)
+			texflag[passindex] |= 0x1;
+	}
+	if(glGetUniformLocationARB(m_filters[passindex], "bgl_LuminanceTexture") != -1)
+	{
+		texflag[passindex] |= 0x2;
+	}
+
+	if(m_gameObjects[passindex])
+	{
+		int objProperties = propNames.size();
+		int i;
+		for(i=0; i<objProperties; i++)
+			if(glGetUniformLocationARB(m_filters[passindex], propNames[i]) != -1)
+				m_properties[passindex].push_back(propNames[i]);
+	}
+}
 
 void RAS_2DFilterManager::StartShaderProgram(int passindex)
 {
@@ -177,7 +203,7 @@ void RAS_2DFilterManager::StartShaderProgram(int passindex)
     }
 
     /* send luminance texture to glsl program if it needs */
-	if(texflag[passindex] & 0x1){
+	if(texflag[passindex] & 0x2){
     	uniformLoc = glGetUniformLocationARB(m_filters[passindex], "bgl_LuminanceTexture");
     	glActiveTextureARB(GL_TEXTURE2);
     	glBindTexture(GL_TEXTURE_2D, texname[2]);
@@ -203,6 +229,17 @@ void RAS_2DFilterManager::StartShaderProgram(int passindex)
     {
 		glUniform1fARB(uniformLoc,textureheight);
     }
+
+	int i, objProperties = m_properties[passindex].size();
+	for(i=0; i<objProperties; i++)
+	{
+		uniformLoc = glGetUniformLocationARB(m_filters[passindex], m_properties[passindex][i]);
+		if(uniformLoc != -1)
+		{
+			float value = ((CValue*)m_gameObjects[passindex])->GetPropertyNumber(m_properties[passindex][i], 0.0);
+			glUniform1fARB(uniformLoc,value);
+		}
+	}
 }
 
 void RAS_2DFilterManager::EndShaderProgram()
@@ -210,45 +247,61 @@ void RAS_2DFilterManager::EndShaderProgram()
 	glUseProgramObjectARB(0);
 }
 
-void RAS_2DFilterManager::SetupTexture()
+void RAS_2DFilterManager::FreeTextures()
 {
-	if(texname[0]!=-1 || texname[1]!=-1)
-	{
-		glDeleteTextures(2, (GLuint*)texname);
-	}
-	glGenTextures(3, (GLuint*)texname);
+	if(texname[0]!=-1)
+		glDeleteTextures(1, (GLuint*)&texname[0]);
+	if(texname[1]!=-1)
+		glDeleteTextures(1, (GLuint*)&texname[1]);
+	if(texname[2]!=-1)
+		glDeleteTextures(1, (GLuint*)&texname[2]);
+}
 
+void RAS_2DFilterManager::SetupTextures(bool depth, bool luminance)
+{
+	FreeTextures();
+	
+	glGenTextures(1, (GLuint*)&texname[0]);
 	glBindTexture(GL_TEXTURE_2D, texname[0]);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texturewidth, textureheight, 0, GL_RGB,
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texturewidth, textureheight, 0, GL_RGBA,
 			GL_UNSIGNED_BYTE, 0);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
-	glBindTexture(GL_TEXTURE_2D, texname[1]);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, texturewidth,textureheight, 0, GL_DEPTH_COMPONENT,
-			GL_FLOAT,NULL);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
+	if(depth){
+		glGenTextures(1, (GLuint*)&texname[1]);
+		glBindTexture(GL_TEXTURE_2D, texname[1]);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, texturewidth,textureheight, 
+			0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE,NULL);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
 		                GL_NONE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-	
-	glBindTexture(GL_TEXTURE_2D, texname[2]);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE16, texturewidth, textureheight, 0, GL_LUMINANCE,
-			GL_UNSIGNED_BYTE, 0);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	}
+
+	if(luminance){
+		glGenTextures(1, (GLuint*)&texname[2]);
+		glBindTexture(GL_TEXTURE_2D, texname[2]);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE16, texturewidth, textureheight,
+			 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+	}
 }
 
-void RAS_2DFilterManager::UpdateOffsetMatrix(int width, int height)
+void RAS_2DFilterManager::UpdateOffsetMatrix(RAS_ICanvas* canvas)
 {
-	canvaswidth = texturewidth = width;
-	canvasheight = textureheight = height;
+	RAS_Rect canvas_rect = canvas->GetWindowArea();
+	canvaswidth = canvas->GetWidth();
+	canvasheight = canvas->GetHeight();
+	texturewidth = canvaswidth + canvas_rect.GetLeft();
+	textureheight = canvasheight + canvas_rect.GetBottom();
 
 	GLint i,j;
 	i = 0;
@@ -273,62 +326,74 @@ void RAS_2DFilterManager::UpdateOffsetMatrix(int width, int height)
 			textureoffsets[(((i*3)+j)*2)+1] = (-1.0f * yInc) + ((GLfloat)j * yInc);
 		}
 	}
-
-	SetupTexture();
 }
 
 void RAS_2DFilterManager::RenderFilters(RAS_ICanvas* canvas)
 {
+	bool need_depth=false;
+	bool need_luminance=false;
+	int num_filters = 0;
+
+	int passindex;
+
 	if(!isshadersupported)
 		return;
 
+	for(passindex =0; passindex<MAX_RENDER_PASS; passindex++)
+	{
+		if(m_filters[passindex] && m_enabled[passindex]){
+			num_filters ++;
+			if(texflag[passindex] & 0x1)
+				need_depth = true;
+			if(texflag[passindex] & 0x2)
+				need_luminance = true;
+			if(need_depth && need_luminance)
+				break;
+		}
+	}
+
+	if(num_filters <= 0)
+		return;
+
 	if(canvaswidth != canvas->GetWidth() || canvasheight != canvas->GetHeight())
 	{
-		UpdateOffsetMatrix(canvas->GetWidth(), canvas->GetHeight());
+		UpdateOffsetMatrix(canvas);
+		SetupTextures(need_depth, need_luminance);
 	}
 	GLuint	viewport[4]={0};
 
-	int passindex;
-	bool first = true;
+	if(need_depth){
+		glActiveTextureARB(GL_TEXTURE1);
+		glBindTexture(GL_TEXTURE_2D, texname[1]);
+		glCopyTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT, 0, 0, texturewidth,textureheight, 0);
+	}
+	
+	if(need_luminance){
+		glActiveTextureARB(GL_TEXTURE2);
+		glBindTexture(GL_TEXTURE_2D, texname[2]);
+		glCopyTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE16, 0, 0 , texturewidth,textureheight, 0);
+	}
+
+	glGetIntegerv(GL_VIEWPORT,(GLint *)viewport);
+	glViewport(0,0, texturewidth, textureheight);
+
+	glDisable(GL_DEPTH_TEST);
+	glMatrixMode(GL_TEXTURE);
+	glLoadIdentity();
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
 
 	for(passindex =0; passindex<MAX_RENDER_PASS; passindex++)
 	{
 		if(m_filters[passindex] && m_enabled[passindex])
 		{
-			if(first)
-			{
-				/* this pass needs depth texture*/
-				if(texflag[passindex] & 0x1){
-					glActiveTextureARB(GL_TEXTURE1);
-					glBindTexture(GL_TEXTURE_2D, texname[1]);
-					glCopyTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT, 0,0, texturewidth,textureheight, 0);
-				}
-				
-				/* this pass needs luminance texture*/
-				if(texflag[passindex] & 0x2){
-					glActiveTextureARB(GL_TEXTURE2);
-					glBindTexture(GL_TEXTURE_2D, texname[2]);
-					glCopyTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE16, 0,0, texturewidth,textureheight, 0);
-				}
-
-				glGetIntegerv(GL_VIEWPORT,(GLint *)viewport);
-				glViewport(0, 0, texturewidth, textureheight);
-
-				glDisable(GL_DEPTH_TEST);
-				glMatrixMode(GL_PROJECTION);
-				glLoadIdentity();
-				glMatrixMode(GL_MODELVIEW);
-				glLoadIdentity();
-				first = false;
-			}
-			
 			StartShaderProgram(passindex);
 
-
 			glActiveTextureARB(GL_TEXTURE0);
 			glBindTexture(GL_TEXTURE_2D, texname[0]);
 			glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, texturewidth, textureheight, 0);
-			   
 			glClear(GL_COLOR_BUFFER_BIT);
 
 			glBegin(GL_QUADS);
@@ -341,15 +406,12 @@ void RAS_2DFilterManager::RenderFilters(RAS_ICanvas* canvas)
 		}
 	}
 
-	if(!first)
-	{
-		glEnable(GL_DEPTH_TEST);
-		glViewport(viewport[0],viewport[1],viewport[2],viewport[3]);
-		EndShaderProgram();	
-	}
+	glEnable(GL_DEPTH_TEST);
+	glViewport(viewport[0],viewport[1],viewport[2],viewport[3]);
+	EndShaderProgram();	
 }
 
-void RAS_2DFilterManager::EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_String& text, short tflag)
+void RAS_2DFilterManager::EnableFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFILTER_MODE mode, int pass, STR_String& text)
 {
 	if(!isshadersupported)
 		return;
@@ -374,16 +436,19 @@ void RAS_2DFilterManager::EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_Str
 			glDeleteObjectARB(m_filters[pass]);
 		m_enabled[pass] = 0;
 		m_filters[pass] = 0;
+		m_gameObjects[pass] = NULL;
+		m_properties[pass].clear();
 		texflag[pass] = 0;
 		return;
 	}
 	
 	if(mode == RAS_2DFILTER_CUSTOMFILTER)
 	{
-		texflag[pass] = tflag;
 		if(m_filters[pass])
 			glDeleteObjectARB(m_filters[pass]);
 		m_filters[pass] = CreateShaderProgram(text.Ptr());
+		m_gameObjects[pass] = gameObj;
+		AnalyseShader(pass, propNames);
 		m_enabled[pass] = 1;
 		return;
 	}
diff --git a/source/gameengine/Rasterizer/RAS_2DFilterManager.h b/source/gameengine/Rasterizer/RAS_2DFilterManager.h
index faf7c652388..f5998e1f093 100644
--- a/source/gameengine/Rasterizer/RAS_2DFilterManager.h
+++ b/source/gameengine/Rasterizer/RAS_2DFilterManager.h
@@ -28,8 +28,6 @@
 #ifndef __RAS_I2DFILTER
 #define __RAS_I2DFILTER
 
-
-
 #define MAX_RENDER_PASS	100
 
 class RAS_2DFilterManager
@@ -37,9 +35,15 @@ class RAS_2DFilterManager
 private:
 	unsigned int	CreateShaderProgram(char* shadersource);
 	unsigned int	CreateShaderProgram(int filtermode);
+	void		AnalyseShader(int passindex, vector<STR_String>& propNames);
 	void			StartShaderProgram(int passindex);
 	void			EndShaderProgram();
 
+	void SetupTextures(bool depth, bool luminance);
+	void FreeTextures();
+
+	void UpdateOffsetMatrix(RAS_ICanvas* canvas);
+
 	float			textureoffsets[18];
 	float			view[4];
 	/* texname[0] contains render to texture, texname[1] contains depth texture,  texname[2] contains luminance texture*/
@@ -54,6 +58,13 @@ private:
 	short			texflag[MAX_RENDER_PASS];
 
 	bool			isshadersupported;
+
+	unsigned int	m_filters[MAX_RENDER_PASS];
+	short		m_enabled[MAX_RENDER_PASS];
+
+	// stores object properties to send to shaders in each pass
+	vector<STR_String>	m_properties[MAX_RENDER_PASS];
+	void* m_gameObjects[MAX_RENDER_PASS];
 public:
 	enum RAS_2DFILTER_MODE {
 		RAS_2DFILTER_ENABLED = -2,
@@ -74,19 +85,12 @@ public:
 		RAS_2DFILTER_NUMBER_OF_FILTERS
 	};
 
-	unsigned int	m_filters[MAX_RENDER_PASS];
-	short			m_enabled[MAX_RENDER_PASS];
-
 	RAS_2DFilterManager();
 
 	~RAS_2DFilterManager();
 
-	void SetupTexture();
-
-	void UpdateOffsetMatrix(int width, int height);
-
 	void RenderFilters(RAS_ICanvas* canvas);
 
-	void EnableFilter(RAS_2DFILTER_MODE mode, int pass, STR_String& text, short tflag);
+	void EnableFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFILTER_MODE mode, int pass, STR_String& text);
 };
 #endif
diff --git a/source/gameengine/Rasterizer/RAS_ICanvas.h b/source/gameengine/Rasterizer/RAS_ICanvas.h
index d799dc9c9bb..f3f817a943d 100644
--- a/source/gameengine/Rasterizer/RAS_ICanvas.h
+++ b/source/gameengine/Rasterizer/RAS_ICanvas.h
@@ -137,6 +137,14 @@ public:
 	) = 0;
 
 	/**
+	 * Used to get canvas area within blender.
+	 */
+	virtual
+		RAS_Rect &
+	GetWindowArea(
+	) = 0;
+
+	/**
 	 * Set the visible vieport 
 	 */
 
diff --git a/source/gameengine/Rasterizer/RAS_IRenderTools.h b/source/gameengine/Rasterizer/RAS_IRenderTools.h
index 781f90d4124..54a663ba111 100644
--- a/source/gameengine/Rasterizer/RAS_IRenderTools.h
+++ b/source/gameengine/Rasterizer/RAS_IRenderTools.h
@@ -185,7 +185,7 @@ public:
 
 	virtual
 		void
-		Update2DFilter(RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text, short textureflag)=0;
+		Update2DFilter(vector<STR_String>& propNames, void* gameObj, RAS_2DFilterManager::RAS_2DFILTER_MODE filtermode, int pass, STR_String& text)=0;
 
 	virtual
 		void
diff --git a/source/gameengine/Rasterizer/SConscript b/source/gameengine/Rasterizer/SConscript
index f077833b850..e6bc657ed6d 100644
--- a/source/gameengine/Rasterizer/SConscript
+++ b/source/gameengine/Rasterizer/SConscript
@@ -7,7 +7,8 @@ if env['WITH_BF_GLEXT'] == 1:
         env['CPPFLAGS'].append('-DWITH_GLEXT')
 
 
-incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines #extern/glew/include'
+incs = '. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/BlenderRoutines #extern/glew/include #source/gameengine/Expressions'
+incs += ' ' + env['BF_PYTHON_INC']
 
 if env['OURPLATFORM']=='win32-vc':
 	cflags = []
diff --git a/source/gameengine/SceneGraph/SG_IObject.cpp b/source/gameengine/SceneGraph/SG_IObject.cpp
index c347bbc6d9a..d0bdac5c8f0 100644
--- a/source/gameengine/SceneGraph/SG_IObject.cpp
+++ b/source/gameengine/SceneGraph/SG_IObject.cpp
@@ -104,7 +104,7 @@ SetSGClientObject(
 }
 
 
-	void
+	bool
 SG_IObject::
 ActivateReplicationCallback(
 	SG_IObject *replica
@@ -112,8 +112,10 @@ ActivateReplicationCallback(
 	if (m_callbacks.m_replicafunc)
 	{
 		// Call client provided replication func
-		m_callbacks.m_replicafunc(replica,m_SGclientObject,m_SGclientInfo);
+		if (m_callbacks.m_replicafunc(replica,m_SGclientObject,m_SGclientInfo) == NULL)
+			return false;
 	}
+	return true;
 };	
 
 	void
diff --git a/source/gameengine/SceneGraph/SG_IObject.h b/source/gameengine/SceneGraph/SG_IObject.h
index 438ab48c556..7f6bdfbbb1c 100644
--- a/source/gameengine/SceneGraph/SG_IObject.h
+++ b/source/gameengine/SceneGraph/SG_IObject.h
@@ -202,7 +202,7 @@ public:
 
 protected :
 
-		void
+		bool
 	ActivateReplicationCallback(
 		SG_IObject *replica
 	);
diff --git a/source/gameengine/SceneGraph/SG_Node.cpp b/source/gameengine/SceneGraph/SG_Node.cpp
index 4e90d7c4653..8de7ac83477 100644
--- a/source/gameengine/SceneGraph/SG_Node.cpp
+++ b/source/gameengine/SceneGraph/SG_Node.cpp
@@ -68,7 +68,7 @@ SG_Node* SG_Node::GetSGReplica()
 	SG_Node* replica = new SG_Node(*this);
 	if (replica == NULL) return NULL;
 
-	ProcessSGReplica(replica);
+	ProcessSGReplica(&replica);
 	
 	return replica;
 }
@@ -76,25 +76,42 @@ SG_Node* SG_Node::GetSGReplica()
 	void 
 SG_Node::
 ProcessSGReplica(
-	SG_Node* replica
+	SG_Node** replica
 ){
 	// Apply the replication call back function.
-	ActivateReplicationCallback(replica);
+	if (!ActivateReplicationCallback(*replica)) 
+	{
+		delete (*replica);
+		*replica = NULL;
+		return;
+	}
 
 	// clear the replica node of it's parent.
-	static_cast<SG_Node*>(replica)->m_SGparent = NULL;
+	static_cast<SG_Node*>(*replica)->m_SGparent = NULL;
 
 	if (m_children.begin() != m_children.end())
 	{
 		// if this node has children, the replica has too, so clear and clone children
-		replica->ClearSGChildren();
+		(*replica)->ClearSGChildren();
 	
 		NodeList::iterator childit;
 		for (childit = m_children.begin();childit!=m_children.end();++childit)
 		{
-			replica->AddChild((*childit)->GetSGReplica());
+			SG_Node* childnode = (*childit)->GetSGReplica();
+			if (childnode)
+				(*replica)->AddChild(childnode);
 		}
 	}
+	// Nodes without children and without client object are
+	// not worth to keep, they will just take up CPU
+	// This can happen in partial replication of hierarchy
+	// during group duplication.
+	if ((*replica)->m_children.empty() && 
+		(*replica)->GetSGClientObject() == NULL)
+	{
+		delete (*replica);
+		*replica = NULL;
+	}
 }
 
 
diff --git a/source/gameengine/SceneGraph/SG_Node.h b/source/gameengine/SceneGraph/SG_Node.h
index f86e3046d93..ffaaad861e2 100644
--- a/source/gameengine/SceneGraph/SG_Node.h
+++ b/source/gameengine/SceneGraph/SG_Node.h
@@ -205,7 +205,7 @@ private:
 
 		void		
 	ProcessSGReplica(
-		SG_Node* replica
+		SG_Node** replica
 	);
 
 	/**